zigbee2mqtt/dist/util/settingsMigration.js

Zigbee to MQTT bridge using Zigbee-herdsman

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.migrateIfNecessary = migrateIfNecessary;
const node_fs_1 = require("node:fs");
const data_1 = __importDefault(require("./data"));
const settings = __importStar(require("./settings"));
const utils_1 = __importDefault(require("./utils"));
const SUPPORTED_VERSIONS = [undefined, 2, 3, 4, settings.CURRENT_VERSION];
function backupSettings(version) {
    const filePath = data_1.default.joinPath("configuration.yaml");
    (0, node_fs_1.copyFileSync)(filePath, filePath.replace(".yaml", `_backup_v${version}.yaml`));
}
/**
 * Set the given path in given settings to given value. If requested, create path.
 *
 * @param currentSettings
 * @param path
 * @param value
 * @param createPathIfNotExist
 * @returns Returns true if value was set, false if not.
 */
// biome-ignore lint/suspicious/noExplicitAny: auto-parsing
function setValue(currentSettings, path, value, createPathIfNotExist = false) {
    for (let i = 0; i < path.length; i++) {
        const key = path[i];
        if (i === path.length - 1) {
            currentSettings[key] = value;
        }
        else {
            if (!currentSettings[key]) {
                if (createPathIfNotExist) {
                    currentSettings[key] = {};
                    /* v8 ignore start */
                }
                else {
                    // invalid path
                    // ignored in test since currently call is always guarded by get-validated path, so this is never reached
                    return false;
                }
                /* v8 ignore stop */
            }
            currentSettings = currentSettings[key];
        }
    }
    return true;
}
/**
 * Get the value at the given path in given settings.
 *
 * @param currentSettings
 * @param path
 * @returns
 *   - true if path was valid
 *   - the value at path
 */
// biome-ignore lint/suspicious/noExplicitAny: auto-parsing
function getValue(currentSettings, path) {
    for (let i = 0; i < path.length; i++) {
        const key = path[i];
        const value = currentSettings[key];
        if (i === path.length - 1) {
            return [value !== undefined, value];
        }
        if (!value) {
            // invalid path
            break;
        }
        currentSettings = value;
    }
    return [false, undefined];
}
/**
 * Add a value at given path, path is created as needed.
 * @param currentSettings
 * @param addition
 */
function addValue(currentSettings, addition) {
    setValue(currentSettings, addition.path, addition.value, true);
}
/**
 * Remove value at given path, if path is valid.
 * Value is actually set to undefined, which triggers removal when `settings.apply` is called.
 * @param currentSettings
 * @param removal
 * @returns
 */
function removeValue(currentSettings, removal) {
    const [validPath, previousValue] = getValue(currentSettings, removal.path);
    if (validPath && previousValue != null) {
        setValue(currentSettings, removal.path, undefined);
    }
    return [validPath, previousValue];
}
/**
 * Change value at given path, if path is valid, and value matched one of the defined values (if any).
 * @param currentSettings
 * @param change
 * @returns
 */
function changeValue(currentSettings, change) {
    const [validPath, previousValue] = getValue(currentSettings, change.path);
    let changed = false;
    if (validPath && previousValue !== change.newValue) {
        if (!change.previousValueAnyOf || change.previousValueAnyOf.includes(previousValue)) {
            setValue(currentSettings, change.path, change.newValue);
            changed = true;
        }
    }
    return [validPath, previousValue, changed];
}
/**
 * Transfer value at given path, to new path.
 * Given path must be valid.
 * New path must not be valid or new path value must be nullish, otherwise given path is removed only.
 * Value at given path is actually set to undefined, which triggers removal when `settings.apply` is called.
 * New path is created as needed.
 * @param currentSettings
 * @param transfer
 * @returns
 */
function transferValue(currentSettings, transfer) {
    const [validPath, previousValue] = getValue(currentSettings, transfer.path);
    const [destValidPath, destValue] = getValue(currentSettings, transfer.newPath);
    const transfered = validPath && previousValue != null && (!destValidPath || destValue == null || Array.isArray(destValue));
    // no point in set if already undefined
    if (validPath && previousValue != null) {
        setValue(currentSettings, transfer.path, undefined);
    }
    if (transfered) {
        if (Array.isArray(previousValue) && Array.isArray(destValue)) {
            setValue(currentSettings, transfer.newPath, [...previousValue, ...destValue], true);
        }
        else {
            setValue(currentSettings, transfer.newPath, previousValue, true);
        }
    }
    return [validPath, previousValue, transfered];
}
const noteIfWasTrue = (previousValue) => previousValue === true;
const noteIfWasDefined = (previousValue) => previousValue != null;
const noteIfWasNonEmptyArray = (previousValue) => Array.isArray(previousValue) && previousValue.length > 0;
function migrateToTwo(currentSettings, transfers, changes, additions, removals, customHandlers) {
    transfers.push({
        path: ["advanced", "homeassistant_discovery_topic"],
        note: "HA discovery_topic was moved from advanced.homeassistant_discovery_topic to homeassistant.discovery_topic.",
        noteIf: noteIfWasDefined,
        newPath: ["homeassistant", "discovery_topic"],
    }, {
        path: ["advanced", "homeassistant_status_topic"],
        note: "HA status_topic was moved from advanced.homeassistant_status_topic to homeassistant.status_topic.",
        noteIf: noteIfWasDefined,
        newPath: ["homeassistant", "status_topic"],
    }, {
        path: ["advanced", "baudrate"],
        note: "Baudrate was moved from advanced.baudrate to serial.baudrate.",
        noteIf: noteIfWasDefined,
        newPath: ["serial", "baudrate"],
    }, {
        path: ["advanced", "rtscts"],
        note: "RTSCTS was moved from advanced.rtscts to serial.rtscts.",
        noteIf: noteIfWasDefined,
        newPath: ["serial", "rtscts"],
    }, {
        path: ["experimental", "transmit_power"],
        note: "Transmit power was moved from experimental.transmit_power to advanced.transmit_power.",
        noteIf: noteIfWasDefined,
        newPath: ["advanced", "transmit_power"],
    }, {
        path: ["experimental", "output"],
        note: "Output was moved from experimental.output to advanced.output.",
        noteIf: noteIfWasDefined,
        newPath: ["advanced", "output"],
    }, {
        path: ["ban"],
        note: "ban was renamed to passlist.",
        noteIf: noteIfWasDefined,
        newPath: ["blocklist"],
    }, {
        path: ["whitelist"],
        note: "whitelist was renamed to passlist.",
        noteIf: noteIfWasDefined,
        newPath: ["passlist"],
    });
    changes.push({
        path: ["advanced", "log_level"],
        note: `Log level 'warn' has been renamed to 'warning'.`,
        noteIf: (previousValue) => previousValue === "warn",
        previousValueAnyOf: ["warn"],
        newValue: "warning",
    });
    additions.push({
        path: ["version"],
        note: "Migrated settings to version 2",
        value: 2,
    });
    const haLegacyTriggers = {
        path: ["homeassistant", "legacy_triggers"],
        note: "Action and click sensors have been removed (homeassistant.legacy_triggers setting). This means all sensor.*_action and sensor.*_click entities are removed. Use the MQTT device trigger instead.",
        noteIf: noteIfWasTrue,
    };
    const haLegacyEntityAttrs = {
        path: ["homeassistant", "legacy_entity_attributes"],
        note: "Entity attributes (homeassistant.legacy_entity_attributes setting) has been removed. This means that entities discovered by Zigbee2MQTT will no longer have entity attributes (Home Assistant entity attributes are accessed via e.g. states.binary_sensor.my_sensor.attributes).",
        noteIf: noteIfWasTrue,
    };
    const otaIkeaUseTestUrl = {
        path: ["ota", "ikea_ota_use_test_url"],
        note: "Due to the OTA rework, the ota.ikea_ota_use_test_url option has been removed.",
        noteIf: noteIfWasTrue,
    };
    removals.push(haLegacyTriggers, haLegacyEntityAttrs, {
        path: ["advanced", "homeassistant_legacy_triggers"],
        note: haLegacyTriggers.note,
        noteIf: haLegacyTriggers.noteIf,
    }, {
        path: ["advanced", "homeassistant_legacy_entity_attributes"],
        note: haLegacyEntityAttrs.note,
        noteIf: haLegacyEntityAttrs.noteIf,
    }, {
        path: ["permit_join"],
        note: "The permit_join setting has been removed, use the frontend or MQTT to permit joining.",
        noteIf: noteIfWasTrue,
    }, otaIkeaUseTestUrl, {
        path: ["advanced", "ikea_ota_use_test_url"],
        note: otaIkeaUseTestUrl.note,
        noteIf: otaIkeaUseTestUrl.noteIf,
    }, {
        path: ["advanced", "legacy_api"],
        note: "The MQTT legacy API has been removed (advanced.legacy_api setting). See link below for affected topics.",
        noteIf: noteIfWasTrue,
    }, {
        path: ["advanced", "legacy_availability_payload"],
        note: 'Due to the removal of advanced.legacy_availability_payload, zigbee2mqtt/bridge/state will now always be a JSON object ({"state":"online"} or {"state":"offline"})',
        noteIf: noteIfWasTrue,
    }, {
        path: ["advanced", "soft_reset_timeout"],
        note: "Removed deprecated: Soft reset feature (advanced.soft_reset_timeout setting)",
        noteIf: noteIfWasDefined,
    }, {
        path: ["advanced", "report"],
        note: "Removed deprecated: Report feature (advanced.report setting)",
        noteIf: noteIfWasTrue,
    }, {
        path: ["advanced", "availability_timeout"],
        note: "Removed deprecated: advanced.availability_timeout availability settings",
        noteIf: noteIfWasDefined,
    }, {
        path: ["advanced", "availability_blocklist"],
        note: "Removed deprecated: advanced.availability_blocklist availability settings",
        noteIf: noteIfWasNonEmptyArray,
    }, {
        path: ["advanced", "availability_passlist"],
        note: "Removed deprecated: advanced.availability_passlist availability settings",
        noteIf: noteIfWasNonEmptyArray,
    }, {
        path: ["advanced", "availability_blacklist"],
        note: "Removed deprecated: advanced.availability_blacklist availability settings",
        noteIf: noteIfWasNonEmptyArray,
    }, {
        path: ["advanced", "availability_whitelist"],
        note: "Removed deprecated: advanced.availability_whitelist availability settings",
        noteIf: noteIfWasNonEmptyArray,
    }, {
        path: ["device_options", "legacy"],
        note: "Removed everything that was enabled through device_options.legacy. See link below for affected devices.",
        noteIf: noteIfWasTrue,
    }, {
        path: ["experimental"],
        note: "The entire experimental section was removed.",
        noteIf: noteIfWasDefined,
    }, {
        path: ["external_converters"],
        note: "External converters are now automatically loaded from the 'data/external_converters' directory without requiring settings to be set. Make sure your external converters are still needed (might be supported out-of-the-box now), and if so, move them to that directory.",
        noteIf: noteIfWasNonEmptyArray,
    });
    // note only once
    const noteEntityOptionsRetrieveState = "Retrieve state option ((devices|groups).xyz.retrieve_state setting)";
    for (const deviceKey in currentSettings.devices) {
        removals.push({
            path: ["devices", deviceKey, "retrieve_state"],
            note: noteEntityOptionsRetrieveState,
            noteIf: noteIfWasTrue,
        });
    }
    for (const groupKey in currentSettings.groups) {
        removals.push({
            path: ["groups", groupKey, "retrieve_state"],
            note: noteEntityOptionsRetrieveState,
            noteIf: noteIfWasTrue,
        });
        removals.push({
            path: ["groups", groupKey, "devices"],
            note: "Removed configuring group members through configuration.yaml (groups.xyz.devices setting). This will not impact current group members; however, you will no longer be able to add or remove devices from a group through the configuration.yaml.",
            noteIf: noteIfWasDefined,
        });
    }
    customHandlers.push();
}
function migrateToThree(_currentSettings, transfers, changes, additions, removals, customHandlers) {
    transfers.push();
    changes.push({
        path: ["version"],
        note: "Migrated settings to version 3",
        newValue: 3,
    });
    additions.push();
    removals.push();
    const changeToObject = (currentSettings, path) => {
        const [validPath, previousValue] = getValue(currentSettings, path);
        if (validPath) {
            if (typeof previousValue === "boolean") {
                setValue(currentSettings, path, { enabled: previousValue });
            }
            else {
                setValue(currentSettings, path, { enabled: true, ...previousValue });
            }
        }
        return [validPath, previousValue, validPath];
    };
    customHandlers.push({
        note: `Property 'homeassistant' is now always an object.`,
        noteIf: () => true,
        execute: (currentSettings) => changeToObject(currentSettings, ["homeassistant"]),
    }, {
        note: `Property 'frontend' is now always an object.`,
        noteIf: () => true,
        execute: (currentSettings) => changeToObject(currentSettings, ["frontend"]),
    }, {
        note: `Property 'availability' is now always an object.`,
        noteIf: () => true,
        execute: (currentSettings) => changeToObject(currentSettings, ["availability"]),
    });
}
function migrateToFour(_currentSettings, transfers, changes, additions, removals, customHandlers) {
    transfers.push();
    changes.push({
        path: ["version"],
        note: "Migrated settings to version 4",
        newValue: 4,
    });
    additions.push();
    removals.push();
    const saveBase64DeviceIconsAsImage = (currentSettings) => {
        const [validPath, previousValue] = getValue(currentSettings, ["devices"]);
        let changed = false;
        if (validPath) {
            for (const deviceKey in currentSettings.devices) {
                const base64Match = utils_1.default.matchBase64File(currentSettings.devices[deviceKey].icon);
                if (base64Match) {
                    changed = true;
                    currentSettings.devices[deviceKey].icon = utils_1.default.saveBase64DeviceIcon(base64Match);
                }
            }
        }
        return [validPath, previousValue, changed];
    };
    customHandlers.push({
        note: "Device icons are now saved as images.",
        noteIf: () => true,
        execute: (currentSettings) => saveBase64DeviceIconsAsImage(currentSettings),
    });
}
function migrateToFive(_currentSettings, transfers, changes, additions, removals, customHandlers) {
    transfers.push();
    changes.push({
        path: ["version"],
        note: "Migrated settings to version 5",
        newValue: 5,
    });
    additions.push();
    removals.push();
    const resetOtaStates = (_currentSettings) => {
        const filePath = data_1.default.joinPath("state.json");
        if ((0, node_fs_1.existsSync)(filePath)) {
            try {
                const stateFile = (0, node_fs_1.readFileSync)(filePath, "utf8");
                const stateObj = JSON.parse(stateFile);
                for (const key in stateObj) {
                    const entry = stateObj[key];
                    if (entry.update) {
                        delete entry.update;
                    }
                }
                (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(stateObj), "utf8");
                // hack, this does not actually affect settings, we just want to ensure the migration note triggers
                return [true, undefined, true];
            }
            catch (error) {
                console.error(`Failed to write state to '${filePath}' (${error})`);
            }
        }
        return [false, undefined, false];
    };
    customHandlers.push({
        note: "Reset all cached OTA states due to internal changes.",
        noteIf: () => true,
        execute: (currentSettings) => resetOtaStates(currentSettings),
    });
}
/**
 * Order of execution:
 * - Transfer
 * - Change
 * - Add
 * - Remove
 *
 * Should allow the most flexibility whenever combination of migrations is necessary (e.g. Transfer + Change)
 */
function migrateIfNecessary() {
    const currentSettings = settings.getPersistedSettings();
    if (!SUPPORTED_VERSIONS.includes(currentSettings.version)) {
        throw new Error(`Your configuration.yaml has an unsupported version ${currentSettings.version}, expected one of ${SUPPORTED_VERSIONS.map((v) => String(v)).join(",")}.`);
    }
    /* v8 ignore next */
    const finalVersion = process.env.VITEST_WORKER_ID ? settings.testing.CURRENT_VERSION : settings.CURRENT_VERSION;
    if (currentSettings.version === finalVersion) {
        // when same version as current, nothing to do
        return;
    }
    while (currentSettings.version !== finalVersion) {
        let migrationNotesFileName;
        // don't duplicate outputs
        const migrationNotes = new Set();
        const transfers = [];
        const changes = [];
        const additions = [];
        const removals = [];
        const customHandlers = [];
        backupSettings(currentSettings.version || 1);
        // each version should only bump to the next version so as to gradually migrate if necessary
        if (currentSettings.version == null) {
            // migrating from 1 (`version` did not exist) to 2
            migrationNotesFileName = "migration-1-to-2.log";
            migrateToTwo(currentSettings, transfers, changes, additions, removals, customHandlers);
        }
        else if (currentSettings.version === 2) {
            migrationNotesFileName = "migration-2-to-3.log";
            migrateToThree(currentSettings, transfers, changes, additions, removals, customHandlers);
        }
        else if (currentSettings.version === 3) {
            migrationNotesFileName = "migration-3-to-4.log";
            migrateToFour(currentSettings, transfers, changes, additions, removals, customHandlers);
        }
        else if (currentSettings.version === 4) {
            migrationNotesFileName = "migration-4-to-5.log";
            migrateToFive(currentSettings, transfers, changes, additions, removals, customHandlers);
        }
        for (const transfer of transfers) {
            const [validPath, previousValue, transfered] = transferValue(currentSettings, transfer);
            if (validPath && (!transfer.noteIf || transfer.noteIf(previousValue))) {
                migrationNotes.add(`[${transfered ? "TRANSFER" : "REMOVAL"}] ${transfer.note}`);
            }
        }
        for (const change of changes) {
            const [validPath, previousValue, changed] = changeValue(currentSettings, change);
            if (validPath && changed && (!change.noteIf || change.noteIf(previousValue))) {
                migrationNotes.add(`[CHANGE] ${change.note}`);
            }
        }
        for (const addition of additions) {
            addValue(currentSettings, addition);
            migrationNotes.add(`[ADDITION] ${addition.note}`);
        }
        for (const removal of removals) {
            const [validPath, previousValue] = removeValue(currentSettings, removal);
            if (validPath && (!removal.noteIf || removal.noteIf(previousValue))) {
                migrationNotes.add(`[REMOVAL] ${removal.note}`);
            }
        }
        for (const customHandler of customHandlers) {
            const [validPath, previousValue, changed] = customHandler.execute(currentSettings);
            if (validPath && changed && (!customHandler.noteIf || customHandler.noteIf(previousValue))) {
                migrationNotes.add(`[SPECIAL] ${customHandler.note}`);
            }
        }
        if (migrationNotesFileName && migrationNotes.size > 0) {
            migrationNotes.add("For more details, see https://github.com/Koenkk/zigbee2mqtt/discussions/24198");
            const migrationNotesFilePath = data_1.default.joinPath(migrationNotesFileName);
            (0, node_fs_1.writeFileSync)(migrationNotesFilePath, Array.from(migrationNotes).join("\r\n\r\n"), "utf8");
            console.log(`Migration notes written in ${migrationNotesFilePath}`);
        }
    }
    // don't throw, onboarding will validate at end of process
    settings.apply(currentSettings, false);
    settings.reRead();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"settingsMigration.js","sourceRoot":"","sources":["../../lib/util/settingsMigration.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+hBA,gDAoGC;AAnoBD,qCAA8E;AAC9E,kDAA0B;AAC1B,qDAAuC;AACvC,oDAA4B;AA2B5B,MAAM,kBAAkB,GAA0B,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;AAEjG,SAAS,cAAc,CAAC,OAAe;IACnC,MAAM,QAAQ,GAAG,cAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;IAErD,IAAA,sBAAY,EAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,OAAO,OAAO,CAAC,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;;;GAQG;AACH,2DAA2D;AAC3D,SAAS,QAAQ,CAAC,eAAoB,EAAE,IAAc,EAAE,KAAc,EAAE,oBAAoB,GAAG,KAAK;IAChG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEpB,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,eAAe,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACjC,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;gBACxB,IAAI,oBAAoB,EAAE,CAAC;oBACvB,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;oBAC1B,qBAAqB;gBACzB,CAAC;qBAAM,CAAC;oBACJ,eAAe;oBACf,yGAAyG;oBACzG,OAAO,KAAK,CAAC;gBACjB,CAAC;gBACD,oBAAoB;YACxB,CAAC;YAED,eAAe,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;QAC3C,CAAC;IACL,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,2DAA2D;AAC3D,SAAS,QAAQ,CAAC,eAAoB,EAAE,IAAc;IAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC;QAEnC,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,eAAe;YACf,MAAM;QACV,CAAC;QAED,eAAe,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,OAAO,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAC9B,CAAC;AAED;;;;GAIG;AACH,SAAS,QAAQ,CAAC,eAAkC,EAAE,QAAqB;IACvE,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAAC,eAAkC,EAAE,OAAuB;IAC5E,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3E,IAAI,SAAS,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;QACrC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,eAAkC,EAAE,MAAsB;IAC3E,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1E,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,IAAI,SAAS,IAAI,aAAa,KAAK,MAAM,CAAC,QAAQ,EAAE,CAAC;QACjD,IAAI,CAAC,MAAM,CAAC,kBAAkB,IAAI,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YAClF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;YAExD,OAAO,GAAG,IAAI,CAAC;QACnB,CAAC;IACL,CAAC;IAED,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,aAAa,CAClB,eAAkC,EAClC,QAA0B;IAE1B,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC5E,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC/E,MAAM,UAAU,GAAG,SAAS,IAAI,aAAa,IAAI,IAAI,IAAI,CAAC,CAAC,aAAa,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IAE3H,uCAAuC;IACvC,IAAI,SAAS,IAAI,aAAa,IAAI,IAAI,EAAE,CAAC;QACrC,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,UAAU,EAAE,CAAC;QACb,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC3D,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,aAAa,EAAE,GAAG,SAAS,CAAC,EAAE,IAAI,CAAC,CAAC;QACxF,CAAC;aAAM,CAAC;YACJ,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QACrE,CAAC;IACL,CAAC;IAED,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;AAClD,CAAC;AAED,MAAM,aAAa,GAAG,CAAC,aAAsB,EAAW,EAAE,CAAC,aAAa,KAAK,IAAI,CAAC;AAClF,MAAM,gBAAgB,GAAG,CAAC,aAAsB,EAAW,EAAE,CAAC,aAAa,IAAI,IAAI,CAAC;AACpF,MAAM,sBAAsB,GAAG,CAAC,aAAsB,EAAW,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC;AAE7H,SAAS,YAAY,CACjB,eAAkC,EAClC,SAA6B,EAC7B,OAAyB,EACzB,SAAwB,EACxB,QAA0B,EAC1B,cAAuC;IAEvC,SAAS,CAAC,IAAI,CACV;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,+BAA+B,CAAC;QACnD,IAAI,EAAE,4GAA4G;QAClH,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,eAAe,EAAE,iBAAiB,CAAC;KAChD,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,4BAA4B,CAAC;QAChD,IAAI,EAAE,mGAAmG;QACzG,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,eAAe,EAAE,cAAc,CAAC;KAC7C,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC;QAC9B,IAAI,EAAE,+DAA+D;QACrE,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,QAAQ,EAAE,UAAU,CAAC;KAClC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QAC5B,IAAI,EAAE,yDAAyD;QAC/D,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;KAChC,EACD;QACI,IAAI,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;QACxC,IAAI,EAAE,uFAAuF;QAC7F,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,UAAU,EAAE,gBAAgB,CAAC;KAC1C,EACD;QACI,IAAI,EAAE,CAAC,cAAc,EAAE,QAAQ,CAAC;QAChC,IAAI,EAAE,+DAA+D;QACrE,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;KAClC,EACD;QACI,IAAI,EAAE,CAAC,KAAK,CAAC;QACb,IAAI,EAAE,8BAA8B;QACpC,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,WAAW,CAAC;KACzB,EACD;QACI,IAAI,EAAE,CAAC,WAAW,CAAC;QACnB,IAAI,EAAE,oCAAoC;QAC1C,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,CAAC,UAAU,CAAC;KACxB,CACJ,CAAC;IAEF,OAAO,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC;QAC/B,IAAI,EAAE,iDAAiD;QACvD,MAAM,EAAE,CAAC,aAAa,EAAW,EAAE,CAAC,aAAa,KAAK,MAAM;QAC5D,kBAAkB,EAAE,CAAC,MAAM,CAAC;QAC5B,QAAQ,EAAE,SAAS;KACtB,CAAC,CAAC;IAEH,SAAS,CAAC,IAAI,CAAC;QACX,IAAI,EAAE,CAAC,SAAS,CAAC;QACjB,IAAI,EAAE,gCAAgC;QACtC,KAAK,EAAE,CAAC;KACX,CAAC,CAAC;IAEH,MAAM,gBAAgB,GAAmB;QACrC,IAAI,EAAE,CAAC,eAAe,EAAE,iBAAiB,CAAC;QAC1C,IAAI,EAAE,kMAAkM;QACxM,MAAM,EAAE,aAAa;KACxB,CAAC;IACF,MAAM,mBAAmB,GAAmB;QACxC,IAAI,EAAE,CAAC,eAAe,EAAE,0BAA0B,CAAC;QACnD,IAAI,EAAE,mRAAmR;QACzR,MAAM,EAAE,aAAa;KACxB,CAAC;IACF,MAAM,iBAAiB,GAAmB;QACtC,IAAI,EAAE,CAAC,KAAK,EAAE,uBAAuB,CAAC;QACtC,IAAI,EAAE,+EAA+E;QACrF,MAAM,EAAE,aAAa;KACxB,CAAC;IAEF,QAAQ,CAAC,IAAI,CACT,gBAAgB,EAChB,mBAAmB,EACnB;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,+BAA+B,CAAC;QACnD,IAAI,EAAE,gBAAgB,CAAC,IAAI;QAC3B,MAAM,EAAE,gBAAgB,CAAC,MAAM;KAClC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,wCAAwC,CAAC;QAC5D,IAAI,EAAE,mBAAmB,CAAC,IAAI;QAC9B,MAAM,EAAE,mBAAmB,CAAC,MAAM;KACrC,EACD;QACI,IAAI,EAAE,CAAC,aAAa,CAAC;QACrB,IAAI,EAAE,uFAAuF;QAC7F,MAAM,EAAE,aAAa;KACxB,EACD,iBAAiB,EACjB;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,uBAAuB,CAAC;QAC3C,IAAI,EAAE,iBAAiB,CAAC,IAAI;QAC5B,MAAM,EAAE,iBAAiB,CAAC,MAAM;KACnC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,YAAY,CAAC;QAChC,IAAI,EAAE,yGAAyG;QAC/G,MAAM,EAAE,aAAa;KACxB,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,6BAA6B,CAAC;QACjD,IAAI,EAAE,mKAAmK;QACzK,MAAM,EAAE,aAAa;KACxB,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,oBAAoB,CAAC;QACxC,IAAI,EAAE,8EAA8E;QACpF,MAAM,EAAE,gBAAgB;KAC3B,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;QAC5B,IAAI,EAAE,8DAA8D;QACpE,MAAM,EAAE,aAAa;KACxB,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,sBAAsB,CAAC;QAC1C,IAAI,EAAE,yEAAyE;QAC/E,MAAM,EAAE,gBAAgB;KAC3B,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,wBAAwB,CAAC;QAC5C,IAAI,EAAE,2EAA2E;QACjF,MAAM,EAAE,sBAAsB;KACjC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,uBAAuB,CAAC;QAC3C,IAAI,EAAE,0EAA0E;QAChF,MAAM,EAAE,sBAAsB;KACjC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,wBAAwB,CAAC;QAC5C,IAAI,EAAE,2EAA2E;QACjF,MAAM,EAAE,sBAAsB;KACjC,EACD;QACI,IAAI,EAAE,CAAC,UAAU,EAAE,wBAAwB,CAAC;QAC5C,IAAI,EAAE,2EAA2E;QACjF,MAAM,EAAE,sBAAsB;KACjC,EACD;QACI,IAAI,EAAE,CAAC,gBAAgB,EAAE,QAAQ,CAAC;QAClC,IAAI,EAAE,yGAAyG;QAC/G,MAAM,EAAE,aAAa;KACxB,EACD;QACI,IAAI,EAAE,CAAC,cAAc,CAAC;QACtB,IAAI,EAAE,8CAA8C;QACpD,MAAM,EAAE,gBAAgB;KAC3B,EACD;QACI,IAAI,EAAE,CAAC,qBAAqB,CAAC;QAC7B,IAAI,EAAE,2QAA2Q;QACjR,MAAM,EAAE,sBAAsB;KACjC,CACJ,CAAC;IAEF,iBAAiB;IACjB,MAAM,8BAA8B,GAAG,qEAAqE,CAAC;IAE7G,KAAK,MAAM,SAAS,IAAI,eAAe,CAAC,OAAO,EAAE,CAAC;QAC9C,QAAQ,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,gBAAgB,CAAC;YAC9C,IAAI,EAAE,8BAA8B;YACpC,MAAM,EAAE,aAAa;SACxB,CAAC,CAAC;IACP,CAAC;IAED,KAAK,MAAM,QAAQ,IAAI,eAAe,CAAC,MAAM,EAAE,CAAC;QAC5C,QAAQ,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,gBAAgB,CAAC;YAC5C,IAAI,EAAE,8BAA8B;YACpC,MAAM,EAAE,aAAa;SACxB,CAAC,CAAC;QACH,QAAQ,CAAC,IAAI,CAAC;YACV,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC;YACrC,IAAI,EAAE,kPAAkP;YACxP,MAAM,EAAE,gBAAgB;SAC3B,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,IAAI,EAAE,CAAC;AAC1B,CAAC;AAED,SAAS,cAAc,CACnB,gBAAmC,EACnC,SAA6B,EAC7B,OAAyB,EACzB,SAAwB,EACxB,QAA0B,EAC1B,cAAuC;IAEvC,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,OAAO,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,CAAC,SAAS,CAAC;QACjB,IAAI,EAAE,gCAAgC;QACtC,QAAQ,EAAE,CAAC;KACd,CAAC,CAAC;IACH,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEhB,MAAM,cAAc,GAAG,CAAC,eAAkC,EAAE,IAAc,EAAgD,EAAE;QACxH,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QAEnE,IAAI,SAAS,EAAE,CAAC;YACZ,IAAI,OAAO,aAAa,KAAK,SAAS,EAAE,CAAC;gBACrC,QAAQ,CAAC,eAAe,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,aAAa,EAAC,CAAC,CAAC;YAC9D,CAAC;iBAAM,CAAC;gBACJ,QAAQ,CAAC,eAAe,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,IAAI,EAAE,GAAI,aAAwB,EAAC,CAAC,CAAC;YACnF,CAAC;QACL,CAAC;QAED,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;IACjD,CAAC,CAAC;IAEF,cAAc,CAAC,IAAI,CACf;QACI,IAAI,EAAE,mDAAmD;QACzD,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;QAClB,OAAO,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,eAAe,CAAC,CAAC;KACnF,EACD;QACI,IAAI,EAAE,8CAA8C;QACpD,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;QAClB,OAAO,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,UAAU,CAAC,CAAC;KAC9E,EACD;QACI,IAAI,EAAE,kDAAkD;QACxD,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;QAClB,OAAO,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,cAAc,CAAC,CAAC;KAClF,CACJ,CAAC;AACN,CAAC;AAED,SAAS,aAAa,CAClB,gBAAmC,EACnC,SAA6B,EAC7B,OAAyB,EACzB,SAAwB,EACxB,QAA0B,EAC1B,cAAuC;IAEvC,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,OAAO,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,CAAC,SAAS,CAAC;QACjB,IAAI,EAAE,gCAAgC;QACtC,QAAQ,EAAE,CAAC;KACd,CAAC,CAAC;IACH,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEhB,MAAM,4BAA4B,GAAG,CAAC,eAAkC,EAAgD,EAAE;QACtH,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,eAAe,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1E,IAAI,OAAO,GAAG,KAAK,CAAC;QAEpB,IAAI,SAAS,EAAE,CAAC;YACZ,KAAK,MAAM,SAAS,IAAI,eAAe,CAAC,OAAO,EAAE,CAAC;gBAC9C,MAAM,WAAW,GAAG,eAAK,CAAC,eAAe,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC;gBACnF,IAAI,WAAW,EAAE,CAAC;oBACd,OAAO,GAAG,IAAI,CAAC;oBACf,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,GAAG,eAAK,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;gBACtF,CAAC;YACL,CAAC;QACL,CAAC;QAED,OAAO,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC,CAAC;IAEF,cAAc,CAAC,IAAI,CAAC;QAChB,IAAI,EAAE,uCAAuC;QAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;QAClB,OAAO,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC,4BAA4B,CAAC,eAAe,CAAC;KAC9E,CAAC,CAAC;AACP,CAAC;AAED,SAAS,aAAa,CAClB,gBAAmC,EACnC,SAA6B,EAC7B,OAAyB,EACzB,SAAwB,EACxB,QAA0B,EAC1B,cAAuC;IAEvC,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,OAAO,CAAC,IAAI,CAAC;QACT,IAAI,EAAE,CAAC,SAAS,CAAC;QACjB,IAAI,EAAE,gCAAgC;QACtC,QAAQ,EAAE,CAAC;KACd,CAAC,CAAC;IACH,SAAS,CAAC,IAAI,EAAE,CAAC;IACjB,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEhB,MAAM,cAAc,GAAG,CAAC,gBAAmC,EAAgD,EAAE;QACzG,MAAM,QAAQ,GAAG,cAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAE7C,IAAI,IAAA,oBAAU,EAAC,QAAQ,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC;gBACD,MAAM,SAAS,GAAG,IAAA,sBAAY,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAa,CAAC;gBAEnD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;oBACzB,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;oBAE5B,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;wBACf,OAAO,KAAK,CAAC,MAAM,CAAC;oBACxB,CAAC;gBACL,CAAC;gBAED,IAAA,uBAAa,EAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC;gBAE1D,mGAAmG;gBACnG,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;YACnC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,6BAA6B,QAAQ,MAAM,KAAK,GAAG,CAAC,CAAC;YACvE,CAAC;QACL,CAAC;QAED,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC,CAAC;IAEF,cAAc,CAAC,IAAI,CAAC;QAChB,IAAI,EAAE,sDAAsD;QAC5D,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI;QAClB,OAAO,EAAE,CAAC,eAAe,EAAE,EAAE,CAAC,cAAc,CAAC,eAAe,CAAC;KAChE,CAAC,CAAC;AACP,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,kBAAkB;IAC9B,MAAM,eAAe,GAAG,QAAQ,CAAC,oBAAoB,EAAE,CAAC;IAExD,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CACX,sDAAsD,eAAe,CAAC,OAAO,qBAAqB,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAC1J,CAAC;IACN,CAAC;IAED,oBAAoB;IACpB,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC;IAEhH,IAAI,eAAe,CAAC,OAAO,KAAK,YAAY,EAAE,CAAC;QAC3C,8CAA8C;QAC9C,OAAO;IACX,CAAC;IAED,OAAO,eAAe,CAAC,OAAO,KAAK,YAAY,EAAE,CAAC;QAC9C,IAAI,sBAA0C,CAAC;QAC/C,0BAA0B;QAC1B,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;QACzC,MAAM,SAAS,GAAuB,EAAE,CAAC;QACzC,MAAM,OAAO,GAAqB,EAAE,CAAC;QACrC,MAAM,SAAS,GAAkB,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAqB,EAAE,CAAC;QACtC,MAAM,cAAc,GAA4B,EAAE,CAAC;QAEnD,cAAc,CAAC,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;QAE7C,4FAA4F;QAC5F,IAAI,eAAe,CAAC,OAAO,IAAI,IAAI,EAAE,CAAC;YAClC,kDAAkD;YAClD,sBAAsB,GAAG,sBAAsB,CAAC;YAEhD,YAAY,CAAC,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC3F,CAAC;aAAM,IAAI,eAAe,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YACvC,sBAAsB,GAAG,sBAAsB,CAAC;YAEhD,cAAc,CAAC,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC7F,CAAC;aAAM,IAAI,eAAe,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YACvC,sBAAsB,GAAG,sBAAsB,CAAC;YAEhD,aAAa,CAAC,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC5F,CAAC;aAAM,IAAI,eAAe,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YACvC,sBAAsB,GAAG,sBAAsB,CAAC;YAEhD,aAAa,CAAC,eAAe,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;QAC5F,CAAC;QAED,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YAC/B,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,UAAU,CAAC,GAAG,aAAa,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;YAExF,IAAI,SAAS,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBACpE,cAAc,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;YACpF,CAAC;QACL,CAAC;QAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC3B,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,GAAG,WAAW,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;YAEjF,IAAI,SAAS,IAAI,OAAO,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBAC3E,cAAc,CAAC,GAAG,CAAC,YAAY,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YAClD,CAAC;QACL,CAAC;QAED,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YAC/B,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;YAEpC,cAAc,CAAC,GAAG,CAAC,cAAc,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,CAAC;QAED,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC7B,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,GAAG,WAAW,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;YAEzE,IAAI,SAAS,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBAClE,cAAc,CAAC,GAAG,CAAC,aAAa,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC;QAED,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YACzC,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;YAEnF,IAAI,SAAS,IAAI,OAAO,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC;gBACzF,cAAc,CAAC,GAAG,CAAC,aAAa,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;YAC1D,CAAC;QACL,CAAC;QAED,IAAI,sBAAsB,IAAI,cAAc,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACpD,cAAc,CAAC,GAAG,CAAC,+EAA+E,CAAC,CAAC;YACpG,MAAM,sBAAsB,GAAG,cAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC;YAErE,IAAA,uBAAa,EAAC,sBAAsB,EAAE,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;YAE3F,OAAO,CAAC,GAAG,CAAC,8BAA8B,sBAAsB,EAAE,CAAC,CAAC;QACxE,CAAC;IACL,CAAC;IAED,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,eAAqD,EAAE,KAAK,CAAC,CAAC;IAC7E,QAAQ,CAAC,MAAM,EAAE,CAAC;AACtB,CAAC"}