tasmota-webserial-esptool 7.3.0 → 7.3.2

package/dist/esp_loader.d.ts

@@ -20,10 +20,14 @@ export declare class ESPLoader extends EventTarget {
     private _reader?;
     private _isESP32S2NativeUSB;
     private _initializationSucceeded;
+    private __commandLock;
+    private _isReconfiguring;
     constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
     private get _inputBuffer();
     private get _totalBytesRead();
     private set _totalBytesRead(value);
+    private get _commandLock();
+    private set _commandLock(value);
     private detectUSBSerialChip;
     initialize(): Promise<void>;
     /**
@@ -65,6 +69,9 @@ export declare class ESPLoader extends EventTarget {
      * Send a command packet, check that the command succeeded and
      * return a tuple with the value and data.
      * See the ESP Serial Protocol for more details on what value/data are
+     *
+     * Commands are serialized to prevent concurrent execution which can cause
+     * WritableStream lock contention on CP210x adapters under Windows
      */
     checkCommand(opcode: number, buffer: number[], checksum?: number, timeout?: number): Promise<[number, number[]]>;
     /**
@@ -188,6 +195,12 @@ export declare class ESPLoader extends EventTarget {
      */
     memFinish(entrypoint?: number): Promise<[number, number[]]>;
     runStub(skipFlashDetection?: boolean): Promise<EspStubLoader>;
+    __writer?: WritableStreamDefaultWriter<Uint8Array>;
+    __writeChain: Promise<void>;
+    private get _writer();
+    private set _writer(value);
+    private get _writeChain();
+    private set _writeChain(value);
     writeToStream(data: number[]): Promise<void>;
     disconnect(): Promise<void>;
     /**

package/dist/esp_loader.js

@@ -23,7 +23,10 @@ export class ESPLoader extends EventTarget {
         this._currentBaudRate = ESP_ROM_BAUD;
         this._isESP32S2NativeUSB = false;
         this._initializationSucceeded = false;
+        this.__commandLock = Promise.resolve([0, []]);
+        this._isReconfiguring = false;
         this.state_DTR = false;
+        this.__writeChain = Promise.resolve();
     }
     get _inputBuffer() {
         return this._parent ? this._parent._inputBuffer : this.__inputBuffer;
@@ -41,6 +44,17 @@ export class ESPLoader extends EventTarget {
             this.__totalBytesRead = value;
         }
     }
+    get _commandLock() {
+        return this._parent ? this._parent._commandLock : this.__commandLock;
+    }
+    set _commandLock(value) {
+        if (this._parent) {
+            this._parent._commandLock = value;
+        }
+        else {
+            this.__commandLock = value;
+        }
+    }
     detectUSBSerialChip(vendorId, productId) {
         // Common USB-Serial chip vendors and their products
         const chips = {
@@ -393,68 +407,78 @@ export class ESPLoader extends EventTarget {
      * Send a command packet, check that the command succeeded and
      * return a tuple with the value and data.
      * See the ESP Serial Protocol for more details on what value/data are
+     *
+     * Commands are serialized to prevent concurrent execution which can cause
+     * WritableStream lock contention on CP210x adapters under Windows
      */
     async checkCommand(opcode, buffer, checksum = 0, timeout = DEFAULT_TIMEOUT) {
-        timeout = Math.min(timeout, MAX_TIMEOUT);
-        await this.sendCommand(opcode, buffer, checksum);
-        const [value, responseData] = await this.getResponse(opcode, timeout);
-        if (responseData === null) {
-            throw new Error("Didn't get enough status bytes");
-        }
-        let data = responseData;
-        let statusLen = 0;
-        if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
-            statusLen = 2;
-        }
-        else if ([
-            CHIP_FAMILY_ESP32,
-            CHIP_FAMILY_ESP32S2,
-            CHIP_FAMILY_ESP32S3,
-            CHIP_FAMILY_ESP32C2,
-            CHIP_FAMILY_ESP32C3,
-            CHIP_FAMILY_ESP32C5,
-            CHIP_FAMILY_ESP32C6,
-            CHIP_FAMILY_ESP32C61,
-            CHIP_FAMILY_ESP32H2,
-            CHIP_FAMILY_ESP32H4,
-            CHIP_FAMILY_ESP32H21,
-            CHIP_FAMILY_ESP32P4,
-            CHIP_FAMILY_ESP32S31,
-        ].includes(this.chipFamily)) {
-            statusLen = 4;
-        }
-        else {
-            // When chipFamily is not yet set (e.g., during GET_SECURITY_INFO in detectChip),
-            // assume modern chips use 4-byte status
-            if (opcode === ESP_GET_SECURITY_INFO) {
-                statusLen = 4;
+        // Serialize command execution to prevent lock contention
+        const executeCommand = async () => {
+            timeout = Math.min(timeout, MAX_TIMEOUT);
+            await this.sendCommand(opcode, buffer, checksum);
+            const [value, responseData] = await this.getResponse(opcode, timeout);
+            if (responseData === null) {
+                throw new Error("Didn't get enough status bytes");
             }
-            else if ([2, 4].includes(data.length)) {
-                statusLen = data.length;
+            let data = responseData;
+            let statusLen = 0;
+            if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
+                statusLen = 2;
             }
-        }
-        if (data.length < statusLen) {
-            throw new Error("Didn't get enough status bytes");
-        }
-        const status = data.slice(-statusLen, data.length);
-        data = data.slice(0, -statusLen);
-        if (this.debug) {
-            this.logger.debug("status", status);
-            this.logger.debug("value", value);
-            this.logger.debug("data", data);
-        }
-        if (status[0] == 1) {
-            if (status[1] == ROM_INVALID_RECV_MSG) {
-                // Unsupported command can result in more than one error response
-                // Use drainInputBuffer for CP210x compatibility on Windows
-                await this.drainInputBuffer(200);
-                throw new Error("Invalid (unsupported) command " + toHex(opcode));
+            else if ([
+                CHIP_FAMILY_ESP32,
+                CHIP_FAMILY_ESP32S2,
+                CHIP_FAMILY_ESP32S3,
+                CHIP_FAMILY_ESP32C2,
+                CHIP_FAMILY_ESP32C3,
+                CHIP_FAMILY_ESP32C5,
+                CHIP_FAMILY_ESP32C6,
+                CHIP_FAMILY_ESP32C61,
+                CHIP_FAMILY_ESP32H2,
+                CHIP_FAMILY_ESP32H4,
+                CHIP_FAMILY_ESP32H21,
+                CHIP_FAMILY_ESP32P4,
+                CHIP_FAMILY_ESP32S31,
+            ].includes(this.chipFamily)) {
+                statusLen = 4;
             }
             else {
-                throw new Error("Command failure error code " + toHex(status[1]));
+                // When chipFamily is not yet set (e.g., during GET_SECURITY_INFO in detectChip),
+                // assume modern chips use 4-byte status
+                if (opcode === ESP_GET_SECURITY_INFO) {
+                    statusLen = 4;
+                }
+                else if ([2, 4].includes(data.length)) {
+                    statusLen = data.length;
+                }
             }
-        }
-        return [value, data];
+            if (data.length < statusLen) {
+                throw new Error("Didn't get enough status bytes");
+            }
+            const status = data.slice(-statusLen, data.length);
+            data = data.slice(0, -statusLen);
+            if (this.debug) {
+                this.logger.debug("status", status);
+                this.logger.debug("value", value);
+                this.logger.debug("data", data);
+            }
+            if (status[0] == 1) {
+                if (status[1] == ROM_INVALID_RECV_MSG) {
+                    // Unsupported command can result in more than one error response
+                    // Use drainInputBuffer for CP210x compatibility on Windows
+                    await this.drainInputBuffer(200);
+                    throw new Error("Invalid (unsupported) command " + toHex(opcode));
+                }
+                else {
+                    throw new Error("Command failure error code " + toHex(status[1]));
+                }
+            }
+            return [value, data];
+        };
+        // Chain command execution through the lock
+        // Use both .then() handlers to ensure lock continues even on error
+        this._commandLock = this._commandLock.then(executeCommand, executeCommand);
+        return this._commandLock;
     }
     /**
      * @name sendCommand
@@ -624,6 +648,24 @@ export class ESPLoader extends EventTarget {
     async reconfigurePort(baud) {
         var _a;
         try {
+            this._isReconfiguring = true;
+            // Wait for pending writes to complete
+            try {
+                await this._writeChain;
+            }
+            catch (err) {
+                this.logger.debug(`Pending write error during reconfigure: ${err}`);
+            }
+            // Release persistent writer before closing
+            if (this._writer) {
+                try {
+                    this._writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Writer release error during reconfigure: ${err}`);
+                }
+                this._writer = undefined;
+            }
             // SerialPort does not allow to be reconfigured while open so we close and re-open
             // reader.cancel() causes the Promise returned by the read() operation running on
             // the readLoop to return immediately with { value: undefined, done: true } and thus
@@ -641,6 +683,9 @@ export class ESPLoader extends EventTarget {
             this.logger.error(`Reconfigure port error: ${e}`);
             throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
         }
+        finally {
+            this._isReconfiguring = false;
+        }
     }
     /**
      * @name connectWithResetStrategies
@@ -1200,19 +1245,83 @@ export class ESPLoader extends EventTarget {
         }
         return espStubLoader;
     }
+    get _writer() {
+        return this._parent ? this._parent._writer : this.__writer;
+    }
+    set _writer(value) {
+        if (this._parent) {
+            this._parent._writer = value;
+        }
+        else {
+            this.__writer = value;
+        }
+    }
+    get _writeChain() {
+        return this._parent ? this._parent._writeChain : this.__writeChain;
+    }
+    set _writeChain(value) {
+        if (this._parent) {
+            this._parent._writeChain = value;
+        }
+        else {
+            this.__writeChain = value;
+        }
+    }
     async writeToStream(data) {
         if (!this.port.writable) {
             this.logger.debug("Port writable stream not available, skipping write");
             return;
         }
-        const writer = this.port.writable.getWriter();
-        await writer.write(new Uint8Array(data));
-        try {
-            writer.releaseLock();
-        }
-        catch (err) {
-            this.logger.error(`Ignoring release lock error: ${err}`);
+        if (this._isReconfiguring) {
+            throw new Error("Cannot write during port reconfiguration");
         }
+        // Queue writes to prevent lock contention (critical for CP2102 on Windows)
+        this._writeChain = this._writeChain
+            .then(async () => {
+            // Check if port is still writable before attempting write
+            if (!this.port.writable) {
+                throw new Error("Port became unavailable during write");
+            }
+            // Get or create persistent writer
+            if (!this._writer) {
+                try {
+                    this._writer = this.port.writable.getWriter();
+                }
+                catch (err) {
+                    this.logger.error(`Failed to get writer: ${err}`);
+                    throw err;
+                }
+            }
+            // Perform the write
+            await this._writer.write(new Uint8Array(data));
+        }, async () => {
+            // Previous write failed, but still attempt this write
+            if (!this.port.writable) {
+                throw new Error("Port became unavailable during write");
+            }
+            // Writer was likely cleaned up by previous error, create new one
+            if (!this._writer) {
+                this._writer = this.port.writable.getWriter();
+            }
+            await this._writer.write(new Uint8Array(data));
+        })
+            .catch((err) => {
+            this.logger.error(`Write error: ${err}`);
+            // Ensure writer is cleaned up on any error
+            if (this._writer) {
+                try {
+                    this._writer.releaseLock();
+                }
+                catch (e) {
+                    // Ignore release errors
+                }
+                this._writer = undefined;
+            }
+            // Re-throw to propagate error
+            throw err;
+        });
+        // Always await the write chain to ensure errors are caught
+        await this._writeChain;
     }
     async disconnect() {
         if (this._parent) {
@@ -1223,15 +1332,50 @@ export class ESPLoader extends EventTarget {
             this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
-        await this.port.writable.getWriter().close();
-        await new Promise((resolve) => {
-            if (!this._reader) {
-                resolve(undefined);
+        try {
+            this._isReconfiguring = true;
+            // Wait for pending writes to complete
+            try {
+                await this._writeChain;
             }
-            this.addEventListener("disconnect", resolve, { once: true });
-            this._reader.cancel();
-        });
-        this.connected = false;
+            catch (err) {
+                this.logger.debug(`Pending write error during disconnect: ${err}`);
+            }
+            // Release persistent writer before closing
+            if (this._writer) {
+                try {
+                    await this._writer.close();
+                    this._writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Writer close/release error: ${err}`);
+                }
+                this._writer = undefined;
+            }
+            else {
+                // No persistent writer exists, close stream directly
+                // This path is taken when no writes have been queued
+                try {
+                    const writer = this.port.writable.getWriter();
+                    await writer.close();
+                    writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Direct writer close error: ${err}`);
+                }
+            }
+            await new Promise((resolve) => {
+                if (!this._reader) {
+                    resolve(undefined);
+                }
+                this.addEventListener("disconnect", resolve, { once: true });
+                this._reader.cancel();
+            });
+            this.connected = false;
+        }
+        finally {
+            this._isReconfiguring = false;
+        }
     }
     /**
      * @name reconnectAndResume
@@ -1242,82 +1386,105 @@ export class ESPLoader extends EventTarget {
             await this._parent.reconnect();
             return;
         }
-        this.logger.log("Reconnecting serial port...");
-        this.connected = false;
-        this.__inputBuffer = [];
-        // Cancel reader
-        if (this._reader) {
+        try {
+            this._isReconfiguring = true;
+            this.logger.log("Reconnecting serial port...");
+            this.connected = false;
+            this.__inputBuffer = [];
+            // Wait for pending writes to complete
             try {
-                await this._reader.cancel();
+                await this._writeChain;
             }
             catch (err) {
-                this.logger.debug(`Reader cancel error: ${err}`);
+                this.logger.debug(`Pending write error during reconnect: ${err}`);
             }
-            this._reader = undefined;
-        }
-        // Close port
-        try {
-            await this.port.close();
-            this.logger.log("Port closed");
-        }
-        catch (err) {
-            this.logger.debug(`Port close error: ${err}`);
-        }
-        // Open the port
-        this.logger.debug("Opening port...");
-        try {
-            await this.port.open({ baudRate: ESP_ROM_BAUD });
-            this.connected = true;
-        }
-        catch (err) {
-            throw new Error(`Failed to open port: ${err}`);
-        }
-        // Verify port streams are available
-        if (!this.port.readable || !this.port.writable) {
-            throw new Error(`Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
-        }
-        // Save chip info and flash size (no need to detect again)
-        const savedChipFamily = this.chipFamily;
-        const savedChipName = this.chipName;
-        const savedChipRevision = this.chipRevision;
-        const savedChipVariant = this.chipVariant;
-        const savedFlashSize = this.flashSize;
-        // Reinitialize
-        await this.hardReset(true);
-        if (!this._parent) {
-            this.__inputBuffer = [];
-            this.__totalBytesRead = 0;
-            this.readLoop();
-        }
-        await this.flushSerialBuffers();
-        await this.sync();
-        // Restore chip info
-        this.chipFamily = savedChipFamily;
-        this.chipName = savedChipName;
-        this.chipRevision = savedChipRevision;
-        this.chipVariant = savedChipVariant;
-        this.flashSize = savedFlashSize;
-        this.logger.debug(`Reconnect complete (chip: ${this.chipName})`);
-        // Verify port is ready
-        if (!this.port.writable || !this.port.readable) {
-            throw new Error("Port not ready after reconnect");
-        }
-        // Load stub
-        const stubLoader = await this.runStub(true);
-        this.logger.debug("Stub loaded");
-        // Restore baudrate if it was changed
-        if (this._currentBaudRate !== ESP_ROM_BAUD) {
-            await stubLoader.setBaudrate(this._currentBaudRate);
-            // Verify port is still ready after baudrate change
+            // Release persistent writer
+            if (this._writer) {
+                try {
+                    this._writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Writer release error during reconnect: ${err}`);
+                }
+                this._writer = undefined;
+            }
+            // Cancel reader
+            if (this._reader) {
+                try {
+                    await this._reader.cancel();
+                }
+                catch (err) {
+                    this.logger.debug(`Reader cancel error: ${err}`);
+                }
+                this._reader = undefined;
+            }
+            // Close port
+            try {
+                await this.port.close();
+                this.logger.log("Port closed");
+            }
+            catch (err) {
+                this.logger.debug(`Port close error: ${err}`);
+            }
+            // Open the port
+            this.logger.debug("Opening port...");
+            try {
+                await this.port.open({ baudRate: ESP_ROM_BAUD });
+                this.connected = true;
+            }
+            catch (err) {
+                throw new Error(`Failed to open port: ${err}`);
+            }
+            // Verify port streams are available
+            if (!this.port.readable || !this.port.writable) {
+                throw new Error(`Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+            }
+            // Save chip info and flash size (no need to detect again)
+            const savedChipFamily = this.chipFamily;
+            const savedChipName = this.chipName;
+            const savedChipRevision = this.chipRevision;
+            const savedChipVariant = this.chipVariant;
+            const savedFlashSize = this.flashSize;
+            // Reinitialize
+            await this.hardReset(true);
+            if (!this._parent) {
+                this.__inputBuffer = [];
+                this.__totalBytesRead = 0;
+                this.readLoop();
+            }
+            await this.flushSerialBuffers();
+            await this.sync();
+            // Restore chip info
+            this.chipFamily = savedChipFamily;
+            this.chipName = savedChipName;
+            this.chipRevision = savedChipRevision;
+            this.chipVariant = savedChipVariant;
+            this.flashSize = savedFlashSize;
+            this.logger.debug(`Reconnect complete (chip: ${this.chipName})`);
+            // Verify port is ready
             if (!this.port.writable || !this.port.readable) {
-                throw new Error(`Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+                throw new Error("Port not ready after reconnect");
             }
+            // Load stub
+            const stubLoader = await this.runStub(true);
+            this.logger.debug("Stub loaded");
+            // Restore baudrate if it was changed
+            if (this._currentBaudRate !== ESP_ROM_BAUD) {
+                await stubLoader.setBaudrate(this._currentBaudRate);
+                // Verify port is still ready after baudrate change
+                if (!this.port.writable || !this.port.readable) {
+                    throw new Error(`Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+                }
+            }
+            // Copy stub state to this instance if we're a stub loader
+            if (this.IS_STUB) {
+                Object.assign(this, stubLoader);
+            }
+            this.logger.debug("Reconnection successful");
         }
-        // Copy stub state to this instance if we're a stub loader
-        if (this.IS_STUB) {
-            Object.assign(this, stubLoader);
+        finally {
+            this._isReconfiguring = false;
         }
-        this.logger.debug("Reconnection successful");
     }
     /**
      * @name drainInputBuffer

package/dist/stubs/esp32c3.json

@@ -1,8 +1,8 @@
 {
-    "entry": 1077413608,
-    "text": "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",
+    "entry": 1077413654,
+    "text": "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",
     "text_start": 1077411840,
-    "data": "FEDIP6wKOEAWCzhAqAs4QHwMOEDkDDhAkgw4QIYJOEA4DDhAeAw4QMQLOEA2CThA7As4QDYJOECKCjhA1Ao4QBYLOECoCzhAnAo4QK4JOED6CThAmAo4QN4OOEAWCzhAoA04QJoOOED0CDhAwA44QPQIOED0CDhA9Ag4QPQIOED0CDhA9Ag4QPQIOED0CDhARg04QPQIOEC4DThAmg44QA==",
+    "data": "FEDIP9oKOEBECzhA1gs4QKoMOEASDThAwAw4QLQJOEBmDDhApgw4QPILOEBkCThAGgw4QGQJOEC4CjhAAgs4QEQLOEDWCzhAygo4QNwJOEAoCjhAxgo4QAwPOEBECzhAzg04QMgOOEAiCThA7g44QCIJOEAiCThAIgk4QCIJOEAiCThAIgk4QCIJOEAiCThAdA04QCIJOEDmDThAyA44QA==",
     "data_start": 1070164916,
     "bss_start": 1070088192
 }

package/dist/stubs/esp32c5.json

@@ -1,8 +1,8 @@
 {
-    "entry": 1082133142,
-    "text": "QRG39wBgIsQmwkrAEUcGxrcEhEDYyz6JM4TnAJOEBAAcQJGLmeeyQCJEkkQCSUEBgoADJQkAnEATdfUPgpfNtwERtwcAYE7Gg6mHAErINwmEQCbKUsQGziLMk4THAT6KEwkJAIBAE3T0PxnIAyUKAIMnCQB9FBN19Q+Cl2X43bfyQGJEtwcAYCOoNwHSREJJskkiSgVhgoCTBwAMkEEqh2MY9QCFRwXGI6AFAHlVgoCFRmMH1gAJRWMNpgB9VYKAQgWTB7ANQYVjE/cCiUecwfW3EwbADWMVxwCUwT6FgoCTB9AN4xz3/JTBEwWwDYKAtzWFQEERk4XFugbGcT9jTQUEtzeFQJOHR7IDpwcIg9ZHCBOGFgAjkscINpcjAKcAA9dHCJFnk4cHBGMa9wI3t4RAEwdHsqFnupcDpgcIt/aEQJOGRrZjH+YAI6bHCCOg1wgjkgcIIaD5V+MK9fyyQEEBgoAjptcII6DnCN23NzcAYBMHRwUcQ52L9f83JwBgEwdHBRxDnYv1/4KAQREGxvk/NzcAYLcGAAgjJgcCkwfHAhTDFEP9/ohDskATRfX/BYlBAYKAQREGxsk/fd23NwBgNwcAQJjDmEN9/7JAQQGCgDcDAEADLkMBDUNjDW4CeXFGjr6ItoeDRkEDQoM6iDbIwlYyhy6GqoUFRTbEKsZywhrAoUYG1pfAgv/ngCAislBFYYKAgoB5cSLUJtJK0FLMBtZOzqqELokyhEFKlwCA/+eAIO9jSoAAslAiVJJUAlnySWJKRWGCgKKJY1OKAMFJk5c5AD7AyogmhgLCAUiBRyFHkwYAArFFEUWdNzMENEFOmc6Uwbd5cSLUJtJK0FLMVsoG1k7OqoQuiTKEEwoAApcAgP/ngODohUpjS4AAslAiVJJUAlnySWJK0kpFYYKAETeiiWNUigCTCQACyocmhoFIE5g5AAFHkwYAAslFEUVWwgLA9T2XAID/54CA5E6ZzpQzBDRBVb8BESLMN4SEQBMERAFKyAMpBAEGzibKYwoJCGE1WcW9R4FEY9YnAQRE/YyTtBQAeT2RPbcHhECDx0cAwceXAID/54Cg32E1EESFRz7CAsAyBjcHAAGBSAFIgUeNxGNe5gABR+FGkwWADRVFvT2XAID/54Cg3EFHJaABR5MGAAKTBcAN3bdjWeYCAUfhRpMFAAIVRZk9lwCA/+eAINoFRxxImY8cyBxEupccxPJAYkTSREJJBWGCgAFHkwYAApMFEALBvxxENwcAAbqGsgeZwLcGgAB9F/mPNzcAYFzDFMMcQ/3/zdxBvwERBs5pOzcFhkBsAEEVlwCA/+eAYNuqhwVFneeyR5P3ByA+xskztzcAYJhHtwZAADcFhkBVj5jHskVBFZcAgP/ngMDYMzWgAPJABWGCgEERt4eEQAbGk4dHAQVHI4DnABPXxQCYxwVnfRfMw8jH+Y06laqVsYENZ4zLI6oHADM2wAC6lyOGx7ClPxnBEwVQDLJAQQGCgB1xosw3hIRApsrOxi7Ohs7KyNLE1sLawF7eYtxm2mrYbtaqiRMERAGXAID/54DgyfJFRERj85UAroRjiwQaAylEACaZE1nJABxIY1XwABxEY1/5Bsk5fd23B4RAg8dHAAMpRABjjgcWs+ckAb2LxeuXAID/54BgxbcnAGAjogc0lwCA/+eA4McmilHlNysAYLcrAGA3LABgtywAYJMN8AMTCws0k4sLMBMMjDSTjMw0hUoTdfkDEe0TDQAEY+9NAf1HM7NHARMdQwBBDTmgXTulv5N3+QFBTeXXk1ddQCMg+wBqhs6FXpWXUIP/54CAYyMgLAEjoFwBoTm3JgBgYWeBR5OGhjUJRhMHB2qMQmOOxQBjmucAlwCA/+eAQLuTB0AMXMhxoIUH1bfjhuf+Ps6XAID/54CguDcnAGDyRyMoVzWTBoc1YWcNRhMHB2qMQmOGxQDjgef8hQfVv+ON5/qXAID/54CgtQ3tExg9AIFHSoZWwgLAgUh9GAFHkwYAAslFEUXlNrcnAGAjqlc1MwqqQeqZapnjHgrwlwCA/+eAALIqzpcAgP/ngGCyckUl+VxA9kBGSaaXXMBcRLZJJkqFj1zEZkTWRJZKBkvyW2Jc0lxCXbJdJWEXA4D/ZwAjryaGzoVKhZcAgP/ngICtwbf2QGZE1kRGSbZJJkqWSgZL8ltiXNJcQl2yXSVhgoABESLMN4SEQBMERAGNZ6KXg8fHsAbOJspKyE7GUsRWwlrAmctiRPJA0kRCSbJJIkqSSgJLBWF1u0REY/OVAK6EpcADKUQAKoommRNZyQAcSGNV8AAcRGNf+QR9PH3dtweEQIPHRwCDKkQA2cOT+foPEwkAEDMJOUGXAID/54BAo2P8JAMmhtKFVoWtPpcAgP/ngACiXECml1zAXESFj1zE8kBiRNJEQkmySSJKkkoCSwVhgoDJNmG/k4kJ8EqG0oVWhaaZgTaT2YkAAUszBVkBswUqAWNlOwEzhiRBfbcTBgAQBQsFNhMJCRATe/sP+b8mhtKFVoWXAID/54AgnxN19Q9J2ZMHQAxcyGm3QREGxpcAgP/ngECTA0WFAbJAdRUTNRUAQQGCgEERBsbFNw3FtweEQJOHBwCUR5nON2cJYBMHxxAcQzcG/f99FvGPNwYDAPGO1Y8cw7JAQQGCgEERJsIGxiLESsCqhE03IeEiRLJAAkkmhZJEQQEXA4D/ZwCjhilFlwCA/+eAQIRZFIMnCQCFg4WLkeNt9LJAIkS39wBghMMCSZJEQQGCgGFkN/kAYBMEBGoRCdm/QREGxhMHAAxjGuUAEwWwDVE/EwXADbJAQQFptxMHsA3jG+X+QTcTBdAN9bdBESLEJsIGxiqEswS1AGMXlACyQCJEkkRBAYKAA0UEAAUETT/tt3VxIsUmw87e0tzW2gbHSsETAQGAEwEBgKqENwqEQCgILoSFapcAgP/ngEDvEwoKAJMJAQcV5CgALAiXAID/54Bg7igAwUVRPwFFhWIWkbpAKkSaRApJ9llmWtZaSWGCgCKJY/OKAAVpg0dKAEqGzoUmhYnPFTJKhs6FKAiXAID/54AA6sqUMwQkQW23lwCA/+eAQIUTdfUPed0TBTAGdbcTBQAMfbVBEQbGmT0RwQ1FskBBARfzf/9nAAN0NXEizU7HUsVaweLcBs8my0rJVsPe3hMBAYATAQGAqokuijKLNowCwjE9gBi3BwIAGeGTBwACPoWXAID/54DA34VnY+5nDygItwqEQJcAgP/ngADhAUmTigoAgytE+WNqeQtj7ksDdaCzBCpBY3ObANqEg8dKACaGooVOhYXL7/D/hY03poUihVk9qT8mhqKFKAiXAID/54Dg3KaZJpljfkkBswd5QePhh/0BqJfwf//ngIB3E3X1D2nVBT+BRCMsBPj5W6MJBPgTBTEAl/B//+eAgGV1+QNFNPksAO/wD+iTFwUBY8IHApO3RACRz4Vnk4cHB6aXipeThweAk4cHgCOKp/iFBH2/4x51+5FH44b09CgALAiXAID/54Dg1Nk1wUUoAO07fT0xO5MHAAIZwbcHAgA+hZcAgP/ngCDQhWIWkfpAakTaREpJukkqSppKCkv2W2ZcDWGCgLdXQUl1cZOH94QBRQbHIsUmw0rBzt7S3Nba2tje1uLU5tLq0O7OPtaX8H//54CgYG05Ec23Zwlgk4fHEJhDtwaEQCOk5gC3BgMAVY+Yw3E5Bc23JwtgN0fYUJOHh8ETBxeqmMO3JgtgI6AGwCOgBwCThwbCmMMTh8bBFEM3BgQA0Y4UwyOgBwC3B4RANzeFQJOHBwATB0e7IaAjoAcAkQfj7ef+3TORRWgQKTv5O80zt7eEQJOHR7Khar6aI6D6CLcJhEC3B4BAk4kJAJOHBw8joPkAGTljCwUUtwcBYBMHEAIjrOcMhUVFRZcAgP/ngEC8twWAQAFGk4UFAEVFlwCA/+eAgL239wBgEUeYyzcFAgCXAID/54DAvLcXCWCIX4FFcYlhFRM1FQCX8H//54AAY7cHAEADp0cBhUdj/ecC4Uc+wAFHgUcCwpMIwQMBSIFGAUaTBfAJEUXv8C/eg0fhAxOHd/4TN3cBYxQHDpO3lwNjgAcOgUdBZjeKhEAjgvkAEwcAEJMH9v+FZrcFAAQBRbc7hUATCkoBDWuX8H//54DgU5OLS8FSm4Onygj134OkygiFRyOmCggjCvECg8cUAAlHIxvhAqMK8QIC3E1HY4PnCFFHY4HnCClHY57nAIPHNAADxyQAogfZjxFHY5XnAJxEnEM+3Ek5oUVIGNk2g8Y0AIPHJACiBt2OkWfBB2P31wQTBbANFTYTBcANOT4TBeAOIT6VMaUxQbe3BYBAAUaThQUEFUWXAID/54DgqbcHAGDYRxMFAAITZxcQ2MfJtYVHFbfJRyMb8QJxv4PHFABRR2Nn9wIFR2Nm9wABSRME8A9VpPkXk/f3D0lH42j3/jc3hUCKBxMHh7u6l5xDgocThwcDE3f3DxFG42nm/JOH9wKT9/cPDUdjbPcENzeFQIoHEwdHwLqXnEOCh5MHQAJjkvYYAtwdRAFFhTwBReE0ZT5dPqFFSBh9FOU0dfQBSQFEFayV6nAYgUUBRZfwf//ngMAzFeHRRWgY4TQBRDGoBUSB7pfwf//ngIA5MzSgACmgoUdjhfYABUQBSe2qA6mEAMBEs2eJANIH/ffv8M/gZfUimQVMGcQzBolAkxcGAcGDuedBbIVMQX1jbIwIBUxRxIPHSQAzBolA8csyzu/wD7yX8H//54BgMnJGYsICwIFIAUiBRwFHkwYAApMFEAIVRe/wj7sTBASAEwQEgMm3g8dJAJ3LMs7v8G+4l/B//+eAwC5yRmLCAsCBSAFIgUcBR5MGAAKTBRACFUXv8O+3EwQEgBMEBIC9txNVxgCX8H//54DgLm3VEwRQAzM0gAAtv4PHSQAzBolAhcsyzu/wD7OX8H//54BgKXJGZsICwIFIAUiBRwFHkwYAApMFwA0VRe/wj7JqlA2/E1UGAZfwf//ngCAqZdkTBGADRb8TVcYAl/B//+eAoCgx1XG/oUfjj/boAUkTBAAM8aDBR82/wUcFROOT9uzMRIhE7/DfmHW1k/e2/0FH457n/JhIkWdj5Ock0UeIRMxIAUZjk/YAkEzv8E/QKoRJvZP3tv9BR+Oa5/qcSBFnY2D3IthEiETMSDOJ5wLRRwFGY5P2AJBM7/BvzbeHhECTh0cBDWcjrAcAupcqhCOkJ7GBvbeHhECTh0cBA8cHAGMPBxaYRMEWEwQADGMT1wDAS4FHEwbwDmPB1waDx1QAA8dEAAFJogfZjwPHZABCB12Pg8d0AOIH2Y9jF/YaE3X0D+/w34cTdfkP7/Bfh+/wP5bjHgTOg8cUAElHY2H3GglH43b3zvUXk/f3Dz1H42D3zooH3pecQ4KHM4f0AANHhwGFBzmOSb+3h4RAk4dHAQPHBwBtx9hHYxsHFMBLI4AHAEWz4UdjkPYC3EyYTNRIkEjMRIhEl/B//+eAoBQqiTM0oACtvwFJBUSVv5FHBUTjmfbWt5YAYLhe5Xf9FwVmfY9Rj4hEuN63lgBguFaBRX2PUY+41reWAGD4Xn2PUY/43reWAGD4UvmP0Y/80pfwf//ngCAXObOT9/YA45gH5BPcRgAThIQAAUn9XON9ic1IRJfwf//ngKD5HERYQBBAfY9jh5cBFEKTx/f/9Y9djxjCBQlBBNm/kUc5tcFHBUTjkfbOnETYSCOo+QAjpukAVbkDp8kAE4YG/xHnAc4BSRMEYAxtvYOnCQFj5scGjYrjngbcg6YJAYFFgUdj68cA44MFxp2OPpcjqNkAI6bpAJm5s4X0AIhNswX3AJEHiMGFRem/oUcFROOd9sYDpAkBGcATBIAMI6gJACOmCQAdswFJEwQgDKG9EwQQDIm9AUkTBIAMqbUBSRMEkAyJtRMHIA1jiOcGEwdADeOS57SDxTQAg8ckABOFhAGiBd2NwRXv8G+tLbYJZRMFBXEDqcQAgESX8H//54Cg6bcHAGDYS7cGAAHBFpNXRwESB3WPvYvZj7OHJwMBRbPVhwKX8H//54AA6xMFgD6X8H//54BA5vm81EiQSMxEiETv8C/1wbyDxTQAg8ckABOFhAGiBd2NwRXv8C/HZbyDxzQAA8ckAKIH2Y8TjQf/gyfKAIHnkzddAJ3Ltz2FQDeJhEC3DIRA4QQFRJONTbsTCUkBE4xMAWMHDQCDJ8oAmcNjTIAAY1UECJMHcAwZoJMHkAwjKvoAubwDKIuwg6cNAGrYMzgNAQYIswf5QAUIPt5Czu/w74YDpw0Ackg3hYRApoV8GOKGEBgTBcUCl/B//+eAYObCVwMni7CDpQ0AMw39QB2PvpTyVyMk67AqhL6VI6C9AOF3s4WFQa6XkcMl/ROFTAHv8G+6I6CNAa234xMEnoMnygDjjweckweADJW/nETjmQec7/Bv4wllEwUFcZfwf//ngCDU7/CvyZfwf//ngODYRbrAROMGBJrv8A/hEwWAPpfwf//ngODR7/BvxwKUSbrv8O/GukAqRJpECkn2WWZa1lpGW7ZbJlyWXAZd9k1JYYKA",
+    "entry": 1082133196,
+    "text": "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",
     "text_start": 1082130432,
-    "data": "FACEQPoOgEBkD4BA+A+AQMwQgEA0EYBA4hCAQFQNgECIEIBAyBCAQBQQgEAEDYBAPBCAQAQNgEDWDoBAIg+AQGQPgED4D4BA6A6AQHwNgECqDYBA5A6AQC4TgEBkD4BA8BGAQOoSgEC+DIBAEBOAQL4MgEC+DIBAvgyAQL4MgEC+DIBAvgyAQL4MgEC+DIBAlhGAQL4MgEAIEoBA6hKAQA==",
+    "data": "FACEQDAPgECaD4BALhCAQAIRgEBqEYBAGBGAQIoNgEC+EIBA/hCAQEoQgEA6DYBAchCAQDoNgEAMD4BAWA+AQJoPgEAuEIBAHg+AQLINgEDgDYBAGg+AQGQTgECaD4BAJhKAQCATgED0DIBARhOAQPQMgED0DIBA9AyAQPQMgED0DIBA9AyAQPQMgED0DIBAzBGAQPQMgEA+EoBAIBOAQA==",
     "data_start": 1082469300,
     "bss_start": 1082392576
 }