@aztec/txe 0.46.5 → 0.46.6

package/dest/oracle/txe_oracle.js

@@ -0,0 +1,527 @@
+import { AuthWitness, L1NotePayload, MerkleTreeId, Note, NullifierMembershipWitness, PublicDataWitness, PublicDataWrite, TaggedLog, } from '@aztec/circuit-types';
+import { CallContext, FunctionData, Gas, GlobalVariables, Header, NULLIFIER_SUBTREE_HEIGHT, PUBLIC_DATA_SUBTREE_HEIGHT, PrivateCallStackItem, PrivateCircuitPublicInputs, PrivateContextInputs, PublicCallRequest, PublicDataTreeLeaf, TxContext, computeContractClassId, deriveKeys, getContractClassFromArtifact, } from '@aztec/circuits.js';
+import { Aes128, Schnorr } from '@aztec/circuits.js/barretenberg';
+import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
+import { FunctionSelector, countArgumentsSize, } from '@aztec/foundation/abi';
+import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { applyStringFormatting } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ContractDataOracle } from '@aztec/pxe';
+import { ContractsDataSourcePublicDB, ExecutionError, Oracle, PublicExecutor, WorldStateDB, acvm, createSimulationError, extractCallStack, pickNotes, toACVMWitness, witnessMapToFields, } from '@aztec/simulator';
+import { MerkleTreeSnapshotOperationsFacade } from '@aztec/world-state';
+import { TXEPublicContractDataSource } from '../util/txe_public_contract_data_source.js';
+import { TXEPublicStateDB } from '../util/txe_public_state_db.js';
+export class TXE {
+    constructor(logger, trees, packedValuesCache, noteCache, keyStore, txeDatabase) {
+        this.logger = logger;
+        this.trees = trees;
+        this.packedValuesCache = packedValuesCache;
+        this.noteCache = noteCache;
+        this.keyStore = keyStore;
+        this.txeDatabase = txeDatabase;
+        this.blockNumber = 0;
+        this.sideEffectsCounter = 0;
+        this.functionSelector = FunctionSelector.fromField(new Fr(0));
+        this.version = Fr.ONE;
+        this.chainId = Fr.ONE;
+        this.contractDataOracle = new ContractDataOracle(txeDatabase);
+        this.contractAddress = AztecAddress.random();
+        this.msgSender = AztecAddress.fromField(new Fr(0));
+    }
+    // Utils
+    getChainId() {
+        return Promise.resolve(this.chainId);
+    }
+    getVersion() {
+        return Promise.resolve(this.version);
+    }
+    getMsgSender() {
+        return this.msgSender;
+    }
+    getFunctionSelector() {
+        return this.functionSelector;
+    }
+    setMsgSender(msgSender) {
+        this.msgSender = msgSender;
+    }
+    setFunctionSelector(functionSelector) {
+        this.functionSelector = functionSelector;
+    }
+    getSideEffectsCounter() {
+        return this.sideEffectsCounter;
+    }
+    setSideEffectsCounter(sideEffectsCounter) {
+        this.sideEffectsCounter = sideEffectsCounter;
+    }
+    setContractAddress(contractAddress) {
+        this.contractAddress = contractAddress;
+    }
+    setBlockNumber(blockNumber) {
+        this.blockNumber = blockNumber;
+    }
+    getTrees() {
+        return this.trees;
+    }
+    getContractDataOracle() {
+        return this.contractDataOracle;
+    }
+    getTXEDatabase() {
+        return this.txeDatabase;
+    }
+    getKeyStore() {
+        return this.keyStore;
+    }
+    async addContractInstance(contractInstance) {
+        await this.txeDatabase.addContractInstance(contractInstance);
+    }
+    async addContractArtifact(artifact) {
+        const contractClass = getContractClassFromArtifact(artifact);
+        await this.txeDatabase.addContractArtifact(computeContractClassId(contractClass), artifact);
+    }
+    async getPrivateContextInputs(blockNumber, sideEffectsCounter = this.sideEffectsCounter, isStaticCall = false, isDelegateCall = false) {
+        const trees = this.getTrees();
+        const stateReference = await trees.getStateReference(false);
+        const inputs = PrivateContextInputs.empty();
+        inputs.historicalHeader.globalVariables.blockNumber = new Fr(blockNumber);
+        inputs.historicalHeader.state = stateReference;
+        inputs.callContext.msgSender = this.msgSender;
+        inputs.callContext.storageContractAddress = this.contractAddress;
+        inputs.callContext.isStaticCall = isStaticCall;
+        inputs.callContext.isDelegateCall = isDelegateCall;
+        inputs.startSideEffectCounter = sideEffectsCounter;
+        inputs.callContext.functionSelector = this.functionSelector;
+        return inputs;
+    }
+    getPublicContextInputs() {
+        const inputs = {
+            argsHash: new Fr(0),
+            isStaticCall: false,
+            toFields: function () {
+                return [this.argsHash, new Fr(this.isStaticCall)];
+            },
+        };
+        return inputs;
+    }
+    async avmOpcodeNullifierExists(innerNullifier, targetAddress) {
+        const nullifier = siloNullifier(targetAddress, innerNullifier);
+        const db = this.trees.asLatest();
+        const index = await db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+        return index !== undefined;
+    }
+    async avmOpcodeEmitNullifier(nullifier) {
+        const db = this.trees.asLatest();
+        const siloedNullifier = siloNullifier(this.contractAddress, nullifier);
+        await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, [siloedNullifier.toBuffer()], NULLIFIER_SUBTREE_HEIGHT);
+        return Promise.resolve();
+    }
+    async avmOpcodeEmitNoteHash(innerNoteHash) {
+        const db = this.trees.asLatest();
+        const noteHash = siloNoteHash(this.contractAddress, innerNoteHash);
+        await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, [noteHash]);
+        return Promise.resolve();
+    }
+    deriveKeys(secret) {
+        return deriveKeys(secret);
+    }
+    async addAuthWitness(address, messageHash) {
+        const account = this.txeDatabase.getAccount(address);
+        const privateKey = await this.keyStore.getMasterSecretKey(account.publicKeys.masterIncomingViewingPublicKey);
+        const schnorr = new Schnorr();
+        const signature = schnorr.constructSignature(messageHash.toBuffer(), privateKey).toBuffer();
+        const authWitness = new AuthWitness(messageHash, [...signature]);
+        return this.txeDatabase.addAuthWitness(authWitness.requestHash, authWitness.witness);
+    }
+    async addNullifiers(contractAddress, nullifiers) {
+        const db = this.trees.asLatest();
+        const siloedNullifiers = nullifiers.map(nullifier => siloNullifier(contractAddress, nullifier).toBuffer());
+        await db.batchInsert(MerkleTreeId.NULLIFIER_TREE, siloedNullifiers, NULLIFIER_SUBTREE_HEIGHT);
+    }
+    async addNoteHashes(contractAddress, innerNoteHashes) {
+        const db = this.trees.asLatest();
+        const siloedNoteHashes = innerNoteHashes.map(innerNoteHash => siloNoteHash(contractAddress, innerNoteHash));
+        await db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, siloedNoteHashes);
+    }
+    // TypedOracle
+    getBlockNumber() {
+        return Promise.resolve(this.blockNumber);
+    }
+    getContractAddress() {
+        return Promise.resolve(this.contractAddress);
+    }
+    getRandomField() {
+        return Fr.random();
+    }
+    packArgumentsArray(args) {
+        return Promise.resolve(this.packedValuesCache.pack(args));
+    }
+    packReturns(returns) {
+        return Promise.resolve(this.packedValuesCache.pack(returns));
+    }
+    unpackReturns(returnsHash) {
+        return Promise.resolve(this.packedValuesCache.unpack(returnsHash));
+    }
+    getKeyValidationRequest(pkMHash) {
+        return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
+    }
+    async getContractInstance(address) {
+        const contractInstance = await this.contractDataOracle.getContractInstance(address);
+        if (!contractInstance) {
+            throw new Error(`Contract instance not found for address ${address}`);
+        }
+        return contractInstance;
+    }
+    getMembershipWitness(_blockNumber, _treeId, _leafValue) {
+        throw new Error('Method not implemented.');
+    }
+    async getSiblingPath(blockNumber, treeId, leafIndex) {
+        const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+        const result = await committedDb.getSiblingPath(treeId, leafIndex.toBigInt());
+        return result.toFields();
+    }
+    async getNullifierMembershipWitness(blockNumber, nullifier) {
+        const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+        const index = await committedDb.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+        if (!index) {
+            return undefined;
+        }
+        const leafPreimagePromise = committedDb.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+        const siblingPathPromise = committedDb.getSiblingPath(MerkleTreeId.NULLIFIER_TREE, BigInt(index));
+        const [leafPreimage, siblingPath] = await Promise.all([leafPreimagePromise, siblingPathPromise]);
+        if (!leafPreimage) {
+            return undefined;
+        }
+        return new NullifierMembershipWitness(BigInt(index), leafPreimage, siblingPath);
+    }
+    async getPublicDataTreeWitness(blockNumber, leafSlot) {
+        const committedDb = new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+        const lowLeafResult = await committedDb.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot.toBigInt());
+        if (!lowLeafResult) {
+            return undefined;
+        }
+        else {
+            const preimage = (await committedDb.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index));
+            const path = await committedDb.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+            return new PublicDataWitness(lowLeafResult.index, preimage, path);
+        }
+    }
+    getLowNullifierMembershipWitness(_blockNumber, _nullifier) {
+        throw new Error('Method not implemented.');
+    }
+    getHeader(_blockNumber) {
+        throw new Error('Method not implemented.');
+    }
+    getCompleteAddress(account) {
+        return Promise.resolve(this.txeDatabase.getAccount(account));
+    }
+    getAuthWitness(messageHash) {
+        return this.txeDatabase.getAuthWitness(messageHash);
+    }
+    popCapsule() {
+        throw new Error('Method not implemented.');
+    }
+    getNotes(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, _status) {
+        // Nullified pending notes are already removed from the list.
+        const pendingNotes = this.noteCache.getNotes(this.contractAddress, storageSlot);
+        const notes = pickNotes(pendingNotes, {
+            selects: selectByIndexes.slice(0, numSelects).map((index, i) => ({
+                selector: { index, offset: selectByOffsets[i], length: selectByLengths[i] },
+                value: selectValues[i],
+                comparator: selectComparators[i],
+            })),
+            sorts: sortByIndexes.map((index, i) => ({
+                selector: { index, offset: sortByOffsets[i], length: sortByLengths[i] },
+                order: sortOrder[i],
+            })),
+            limit,
+            offset,
+        });
+        this.logger.debug(`Returning ${notes.length} notes for ${this.contractAddress} at ${storageSlot}: ${notes
+            .map(n => `${n.nonce.toString()}:[${n.note.items.map(i => i.toString()).join(',')}]`)
+            .join(', ')}`);
+        return Promise.resolve(notes);
+    }
+    notifyCreatedNote(storageSlot, noteTypeId, noteItems, innerNoteHash, counter) {
+        const note = new Note(noteItems);
+        this.noteCache.addNewNote({
+            contractAddress: this.contractAddress,
+            storageSlot,
+            nonce: Fr.ZERO, // Nonce cannot be known during private execution.
+            note,
+            siloedNullifier: undefined, // Siloed nullifier cannot be known for newly created note.
+            innerNoteHash,
+        }, counter);
+        return Promise.resolve();
+    }
+    notifyNullifiedNote(innerNullifier, innerNoteHash, _counter) {
+        this.noteCache.nullifyNote(this.contractAddress, innerNullifier, innerNoteHash);
+        return Promise.resolve();
+    }
+    async checkNullifierExists(innerNullifier) {
+        const nullifier = siloNullifier(this.contractAddress, innerNullifier);
+        const db = this.trees.asLatest();
+        const index = await db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+        return index !== undefined;
+    }
+    getL1ToL2MembershipWitness(_contractAddress, _messageHash, _secret) {
+        throw new Error('Method not implemented.');
+    }
+    async avmOpcodeStorageRead(slot, length) {
+        const db = this.trees.asLatest();
+        const result = [];
+        for (let i = 0; i < length.toNumber(); i++) {
+            const leafSlot = computePublicDataTreeLeafSlot(this.contractAddress, slot.add(new Fr(i))).toBigInt();
+            const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+            if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+                result.push(Fr.ZERO);
+                continue;
+            }
+            const preimage = (await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index));
+            result.push(preimage.value);
+        }
+        return result;
+    }
+    async storageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
+        const db = blockNumber === (await this.getBlockNumber())
+            ? this.trees.asLatest()
+            : new MerkleTreeSnapshotOperationsFacade(this.trees, blockNumber);
+        const values = [];
+        for (let i = 0n; i < numberOfElements; i++) {
+            const storageSlot = startStorageSlot.add(new Fr(i));
+            const leafSlot = computePublicDataTreeLeafSlot(contractAddress, storageSlot).toBigInt();
+            const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+            let value = Fr.ZERO;
+            if (lowLeafResult && lowLeafResult.alreadyPresent) {
+                const preimage = (await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index));
+                value = preimage.value;
+            }
+            this.logger.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+            values.push(value);
+        }
+        return values;
+    }
+    async storageWrite(startStorageSlot, values) {
+        const db = this.trees.asLatest();
+        const publicDataWrites = values.map((value, i) => {
+            const storageSlot = startStorageSlot.add(new Fr(i));
+            this.logger.debug(`Oracle storage write: slot=${storageSlot.toString()} value=${value}`);
+            return new PublicDataWrite(computePublicDataTreeLeafSlot(this.contractAddress, storageSlot), value);
+        });
+        await db.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, publicDataWrites.map(write => new PublicDataTreeLeaf(write.leafIndex, write.newValue).toBuffer()), PUBLIC_DATA_SUBTREE_HEIGHT);
+        return publicDataWrites.map(write => write.newValue);
+    }
+    emitEncryptedLog(_contractAddress, _randomness, _encryptedNote, _counter) {
+        return;
+    }
+    emitEncryptedNoteLog(_noteHashCounter, _encryptedNote, _counter) {
+        return;
+    }
+    computeEncryptedNoteLog(contractAddress, storageSlot, noteTypeId, ovKeys, ivpkM, preimage) {
+        const note = new Note(preimage);
+        const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
+        const taggedNote = new TaggedLog(l1NotePayload);
+        const ephSk = GrumpkinScalar.random();
+        const recipient = AztecAddress.random();
+        return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
+    }
+    emitUnencryptedLog(_log, _counter) {
+        return;
+    }
+    emitContractClassUnencryptedLog(_log, _counter) {
+        throw new Error('Method not implemented.');
+    }
+    async callPrivateFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall, isDelegateCall) {
+        this.logger.verbose(`Executing external function ${targetContractAddress}:${functionSelector}(${await this.getDebugFunctionName(targetContractAddress, functionSelector)}) isStaticCall=${isStaticCall} isDelegateCall=${isDelegateCall}`);
+        // Store and modify env
+        const currentContractAddress = AztecAddress.fromField(this.contractAddress);
+        const currentMessageSender = AztecAddress.fromField(this.msgSender);
+        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
+        this.setMsgSender(this.contractAddress);
+        this.setContractAddress(targetContractAddress);
+        this.setFunctionSelector(functionSelector);
+        const artifact = await this.contractDataOracle.getFunctionArtifact(targetContractAddress, functionSelector);
+        const acir = artifact.bytecode;
+        const initialWitness = await this.getInitialWitness(artifact, argsHash, sideEffectCounter, isStaticCall, isDelegateCall);
+        const acvmCallback = new Oracle(this);
+        const timer = new Timer();
+        try {
+            const acirExecutionResult = await acvm(acir, initialWitness, acvmCallback).catch((err) => {
+                const execError = new ExecutionError(err.message, {
+                    contractAddress: targetContractAddress,
+                    functionSelector,
+                }, extractCallStack(err, artifact.debug), { cause: err });
+                this.logger.debug(`Error executing private function ${targetContractAddress}:${functionSelector}`);
+                throw createSimulationError(execError);
+            });
+            const duration = timer.ms();
+            const returnWitness = witnessMapToFields(acirExecutionResult.returnWitness);
+            const publicInputs = PrivateCircuitPublicInputs.fromFields(returnWitness);
+            const initialWitnessSize = witnessMapToFields(initialWitness).length * Fr.SIZE_IN_BYTES;
+            this.logger.debug(`Ran external function ${targetContractAddress.toString()}:${functionSelector}`, {
+                circuitName: 'app-circuit',
+                duration,
+                eventName: 'circuit-witness-generation',
+                inputSize: initialWitnessSize,
+                outputSize: publicInputs.toBuffer().length,
+                appCircuitName: 'noname',
+            });
+            const callStackItem = new PrivateCallStackItem(targetContractAddress, new FunctionData(functionSelector, true), publicInputs);
+            // Apply side effects
+            this.sideEffectsCounter = publicInputs.endSideEffectCounter.toNumber();
+            await this.addNullifiers(targetContractAddress, publicInputs.nullifiers.filter(nullifier => !nullifier.isEmpty()).map(nullifier => nullifier.value));
+            await this.addNoteHashes(targetContractAddress, publicInputs.noteHashes.filter(noteHash => !noteHash.isEmpty()).map(noteHash => noteHash.value));
+            return callStackItem;
+        }
+        finally {
+            this.setContractAddress(currentContractAddress);
+            this.setMsgSender(currentMessageSender);
+            this.setFunctionSelector(currentFunctionSelector);
+        }
+    }
+    async getInitialWitness(abi, argsHash, sideEffectCounter, isStaticCall, isDelegateCall) {
+        const argumentsSize = countArgumentsSize(abi);
+        const args = this.packedValuesCache.unpack(argsHash);
+        if (args.length !== argumentsSize) {
+            throw new Error('Invalid arguments size');
+        }
+        const privateContextInputs = await this.getPrivateContextInputs(this.blockNumber - 1, sideEffectCounter, isStaticCall, isDelegateCall);
+        const fields = [...privateContextInputs.toFields(), ...args];
+        return toACVMWitness(0, fields);
+    }
+    async getDebugFunctionName(address, selector) {
+        const instance = await this.contractDataOracle.getContractInstance(address);
+        if (!instance) {
+            return undefined;
+        }
+        const artifact = await this.contractDataOracle.getContractArtifact(instance.contractClassId);
+        if (!artifact) {
+            return undefined;
+        }
+        const f = artifact.functions.find(f => FunctionSelector.fromNameAndParameters(f.name, f.parameters).equals(selector));
+        if (!f) {
+            return undefined;
+        }
+        return `${artifact.name}:${f.name}`;
+    }
+    async executePublicFunction(targetContractAddress, functionSelector, args, callContext) {
+        const header = Header.empty();
+        header.state = await this.trees.getStateReference(true);
+        header.globalVariables.blockNumber = new Fr(await this.getBlockNumber());
+        header.state.partial.nullifierTree.root = Fr.fromBuffer((await this.trees.getTreeInfo(MerkleTreeId.NULLIFIER_TREE, true)).root);
+        header.state.partial.noteHashTree.root = Fr.fromBuffer((await this.trees.getTreeInfo(MerkleTreeId.NOTE_HASH_TREE, true)).root);
+        header.state.partial.publicDataTree.root = Fr.fromBuffer((await this.trees.getTreeInfo(MerkleTreeId.PUBLIC_DATA_TREE, true)).root);
+        header.state.l1ToL2MessageTree.root = Fr.fromBuffer((await this.trees.getTreeInfo(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, true)).root);
+        const executor = new PublicExecutor(new TXEPublicStateDB(this), new ContractsDataSourcePublicDB(new TXEPublicContractDataSource(this)), new WorldStateDB(this.trees.asLatest()), header);
+        const execution = {
+            contractAddress: targetContractAddress,
+            functionSelector,
+            args,
+            callContext,
+        };
+        return executor.simulate(execution, GlobalVariables.empty(), Gas.test(), TxContext.empty(), 
+        /* pendingNullifiers */ [], 
+        /* transactionFee */ Fr.ONE);
+    }
+    async avmOpcodeCall(targetContractAddress, functionSelector, args, isStaticCall, isDelegateCall) {
+        // Store and modify env
+        const currentContractAddress = AztecAddress.fromField(this.contractAddress);
+        const currentMessageSender = AztecAddress.fromField(this.msgSender);
+        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
+        this.setMsgSender(this.contractAddress);
+        this.setContractAddress(targetContractAddress);
+        this.setFunctionSelector(functionSelector);
+        const callContext = CallContext.empty();
+        callContext.msgSender = this.msgSender;
+        callContext.functionSelector = this.functionSelector;
+        callContext.storageContractAddress = targetContractAddress;
+        callContext.isStaticCall = isStaticCall;
+        callContext.isDelegateCall = isDelegateCall;
+        const executionResult = await this.executePublicFunction(targetContractAddress, functionSelector, args, callContext);
+        // Apply side effects
+        if (!executionResult.reverted) {
+            this.sideEffectsCounter += executionResult.endSideEffectCounter.toNumber();
+        }
+        this.setContractAddress(currentContractAddress);
+        this.setMsgSender(currentMessageSender);
+        this.setFunctionSelector(currentFunctionSelector);
+        return executionResult;
+    }
+    async callPublicFunction(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall, isDelegateCall) {
+        // Store and modify env
+        const currentContractAddress = AztecAddress.fromField(this.contractAddress);
+        const currentMessageSender = AztecAddress.fromField(this.msgSender);
+        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
+        this.setMsgSender(this.contractAddress);
+        this.setContractAddress(targetContractAddress);
+        this.setFunctionSelector(functionSelector);
+        const callContext = CallContext.empty();
+        callContext.msgSender = this.msgSender;
+        callContext.functionSelector = this.functionSelector;
+        callContext.storageContractAddress = targetContractAddress;
+        callContext.isStaticCall = isStaticCall;
+        callContext.isDelegateCall = isDelegateCall;
+        const args = this.packedValuesCache.unpack(argsHash);
+        const executionResult = await this.executePublicFunction(targetContractAddress, functionSelector, args, callContext);
+        // Apply side effects
+        this.sideEffectsCounter = executionResult.endSideEffectCounter.toNumber();
+        this.setContractAddress(currentContractAddress);
+        this.setMsgSender(currentMessageSender);
+        this.setFunctionSelector(currentFunctionSelector);
+        return executionResult.returnValues;
+    }
+    async enqueuePublicFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall, isDelegateCall) {
+        // Store and modify env
+        const currentContractAddress = AztecAddress.fromField(this.contractAddress);
+        const currentMessageSender = AztecAddress.fromField(this.msgSender);
+        const currentFunctionSelector = FunctionSelector.fromField(this.functionSelector.toField());
+        this.setMsgSender(this.contractAddress);
+        this.setContractAddress(targetContractAddress);
+        this.setFunctionSelector(functionSelector);
+        const callContext = CallContext.empty();
+        callContext.msgSender = this.msgSender;
+        callContext.functionSelector = this.functionSelector;
+        callContext.storageContractAddress = targetContractAddress;
+        callContext.isStaticCall = isStaticCall;
+        callContext.isDelegateCall = isDelegateCall;
+        const args = this.packedValuesCache.unpack(argsHash);
+        const executionResult = await this.executePublicFunction(targetContractAddress, functionSelector, args, callContext);
+        // Apply side effects
+        this.sideEffectsCounter += executionResult.endSideEffectCounter.toNumber();
+        this.setContractAddress(currentContractAddress);
+        this.setMsgSender(currentMessageSender);
+        this.setFunctionSelector(currentFunctionSelector);
+        const parentCallContext = CallContext.empty();
+        parentCallContext.msgSender = currentMessageSender;
+        parentCallContext.functionSelector = currentFunctionSelector;
+        parentCallContext.storageContractAddress = currentContractAddress;
+        parentCallContext.isStaticCall = isStaticCall;
+        parentCallContext.isDelegateCall = isDelegateCall;
+        return PublicCallRequest.from({
+            parentCallContext,
+            contractAddress: targetContractAddress,
+            functionSelector,
+            callContext,
+            sideEffectCounter,
+            args,
+        });
+    }
+    setPublicTeardownFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall, isDelegateCall) {
+        // Definitely not right, in that the teardown should always be last.
+        // But useful for executing flows.
+        return this.enqueuePublicFunctionCall(targetContractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall, isDelegateCall);
+    }
+    aes128Encrypt(input, initializationVector, key) {
+        const aes128 = new Aes128();
+        return aes128.encryptBufferCBC(input, initializationVector, key);
+    }
+    debugLog(message, fields) {
+        this.logger.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
+    }
+    emitEncryptedEventLog(_contractAddress, _randomness, _encryptedEvent, _counter) {
+        return;
+    }
+    computeEncryptedEventLog(_contractAddress, _randomness, _eventTypeId, _ovKeys, _ivpkM, _preimage) {
+        throw new Error('Method not implemented.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txe_oracle.js","sourceRoot":"","sources":["../../src/oracle/txe_oracle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,aAAa,EACb,YAAY,EACZ,IAAI,EAEJ,0BAA0B,EAC1B,iBAAiB,EACjB,eAAe,EACf,SAAS,GAEV,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,WAAW,EACX,YAAY,EACZ,GAAG,EACH,eAAe,EACf,MAAM,EAEN,wBAAwB,EAGxB,0BAA0B,EAE1B,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAElB,SAAS,EACT,sBAAsB,EACtB,UAAU,EACV,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,6BAA6B,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACrG,OAAO,EAGL,gBAAgB,EAEhB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAE,cAAc,EAAc,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAe,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC3E,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EACL,2BAA2B,EAC3B,cAAc,EAId,MAAM,EAEN,cAAc,EAEd,YAAY,EACZ,IAAI,EACJ,qBAAqB,EACrB,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,kCAAkC,EAAoB,MAAM,oBAAoB,CAAC;AAG1F,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAElE,MAAM,OAAO,GAAG;IAYd,YACU,MAAc,EACd,KAAkB,EAClB,iBAAoC,EACpC,SAA6B,EAC7B,QAAkB,EAClB,WAAwB;QALxB,WAAM,GAAN,MAAM,CAAQ;QACd,UAAK,GAAL,KAAK,CAAa;QAClB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,cAAS,GAAT,SAAS,CAAoB;QAC7B,aAAQ,GAAR,QAAQ,CAAU;QAClB,gBAAW,GAAX,WAAW,CAAa;QAjB1B,gBAAW,GAAG,CAAC,CAAC;QAChB,uBAAkB,GAAG,CAAC,CAAC;QAGvB,qBAAgB,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAIzD,YAAO,GAAO,EAAE,CAAC,GAAG,CAAC;QACrB,YAAO,GAAO,EAAE,CAAC,GAAG,CAAC;QAU3B,IAAI,CAAC,kBAAkB,GAAG,IAAI,kBAAkB,CAAC,WAAW,CAAC,CAAC;QAC9D,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC;QAC7C,IAAI,CAAC,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC;IAED,QAAQ;IAER,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED,UAAU;QACR,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,mBAAmB;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,YAAY,CAAC,SAAa;QACxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,mBAAmB,CAAC,gBAAkC;QACpD,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;IAC3C,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,qBAAqB,CAAC,kBAA0B;QAC9C,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IAC/C,CAAC;IAED,kBAAkB,CAAC,eAA6B;QAC9C,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;IAED,cAAc,CAAC,WAAmB;QAChC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;IACjC,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED,qBAAqB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,gBAA6C;QACrE,MAAM,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;IAC/D,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,QAA0B;QAClD,MAAM,aAAa,GAAG,4BAA4B,CAAC,QAAQ,CAAC,CAAC;QAC7D,MAAM,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,sBAAsB,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC9F,CAAC;IAED,KAAK,CAAC,uBAAuB,CAC3B,WAAmB,EACnB,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,EAC5C,YAAY,GAAG,KAAK,EACpB,cAAc,GAAG,KAAK;QAEtB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,cAAc,GAAG,MAAM,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,oBAAoB,CAAC,KAAK,EAAE,CAAC;QAC5C,MAAM,CAAC,gBAAgB,CAAC,eAAe,CAAC,WAAW,GAAG,IAAI,EAAE,CAAC,WAAW,CAAC,CAAC;QAC1E,MAAM,CAAC,gBAAgB,CAAC,KAAK,GAAG,cAAc,CAAC;QAC/C,MAAM,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC9C,MAAM,CAAC,WAAW,CAAC,sBAAsB,GAAG,IAAI,CAAC,eAAe,CAAC;QACjE,MAAM,CAAC,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC;QAC/C,MAAM,CAAC,WAAW,CAAC,cAAc,GAAG,cAAc,CAAC;QACnD,MAAM,CAAC,sBAAsB,GAAG,kBAAkB,CAAC;QACnD,MAAM,CAAC,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC5D,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,sBAAsB;QACpB,MAAM,MAAM,GAAG;YACb,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACnB,YAAY,EAAE,KAAK;YACnB,QAAQ,EAAE;gBACR,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YACpD,CAAC;SACF,CAAC;QACF,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,cAAkB,EAAE,aAA2B;QAC5E,MAAM,SAAS,GAAG,aAAa,CAAC,aAAa,EAAE,cAAe,CAAC,CAAC;QAChE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,cAAc,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxF,OAAO,KAAK,KAAK,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,sBAAsB,CAAC,SAAa;QACxC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,eAAe,GAAG,aAAa,CAAC,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC;QACvE,MAAM,EAAE,CAAC,WAAW,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC,EAAE,wBAAwB,CAAC,CAAC;QAC1G,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,qBAAqB,CAAC,aAAiB;QAC3C,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;QACnE,MAAM,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC/D,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,UAAU,CAAC,MAAU;QACnB,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,OAAqB,EAAE,WAAe;QACzD,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,OAAO,CAAC,UAAU,CAAC,8BAA8B,CAAC,CAAC;QAC7G,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,SAAS,GAAG,OAAO,CAAC,kBAAkB,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,UAAU,CAAC,CAAC,QAAQ,EAAE,CAAC;QAC5F,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IACvF,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,eAA6B,EAAE,UAAgB;QACjE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,gBAAgB,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,aAAa,CAAC,eAAe,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;QAE3G,MAAM,EAAE,CAAC,WAAW,CAAC,YAAY,CAAC,cAAc,EAAE,gBAAgB,EAAE,wBAAwB,CAAC,CAAC;IAChG,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,eAA6B,EAAE,eAAqB;QACtE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,gBAAgB,GAAG,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,CAAC;QAC5G,MAAM,EAAE,CAAC,YAAY,CAAC,YAAY,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;IACvE,CAAC;IAED,cAAc;IAEd,cAAc;QACZ,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED,kBAAkB;QAChB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC/C,CAAC;IAED,cAAc;QACZ,OAAO,EAAE,CAAC,MAAM,EAAE,CAAC;IACrB,CAAC;IAED,kBAAkB,CAAC,IAAU;QAC3B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,WAAW,CAAC,OAAa;QACvB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,aAAa,CAAC,WAAe;QAC3B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IACrE,CAAC;IAED,uBAAuB,CAAC,OAAW;QACjC,OAAO,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAC9E,CAAC;IAED,KAAK,CAAC,mBAAmB,CAAC,OAAqB;QAC7C,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QACpF,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,2CAA2C,OAAO,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,oBAAoB,CAAC,YAAoB,EAAE,OAAqB,EAAE,UAAc;QAC9E,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,WAAmB,EAAE,MAAoB,EAAE,SAAa;QAC3E,MAAM,WAAW,GAAG,IAAI,kCAAkC,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACpF,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC9E,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,6BAA6B,CACjC,WAAmB,EACnB,SAAa;QAEb,MAAM,WAAW,GAAG,IAAI,kCAAkC,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACpF,MAAM,KAAK,GAAG,MAAM,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,cAAc,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACjG,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,mBAAmB,GAAG,WAAW,CAAC,eAAe,CAAC,YAAY,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;QAC5F,MAAM,kBAAkB,GAAG,WAAW,CAAC,cAAc,CACnD,YAAY,CAAC,cAAc,EAC3B,MAAM,CAAC,KAAK,CAAC,CACd,CAAC;QAEF,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,CAAC,CAAC;QAEjG,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,0BAA0B,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,YAAqC,EAAE,WAAW,CAAC,CAAC;IAC3G,CAAC;IAED,KAAK,CAAC,wBAAwB,CAAC,WAAmB,EAAE,QAAY;QAC9D,MAAM,WAAW,GAAG,IAAI,kCAAkC,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QACpF,MAAM,aAAa,GAAG,MAAM,WAAW,CAAC,qBAAqB,CAAC,YAAY,CAAC,gBAAgB,EAAE,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;QAClH,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,OAAO,SAAS,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,MAAM,QAAQ,GAAG,CAAC,MAAM,WAAW,CAAC,eAAe,CACjD,YAAY,CAAC,gBAAgB,EAC7B,aAAa,CAAC,KAAK,CACpB,CAA+B,CAAC;YACjC,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,cAAc,CAC3C,YAAY,CAAC,gBAAgB,EAC7B,aAAa,CAAC,KAAK,CACpB,CAAC;YACF,OAAO,IAAI,iBAAiB,CAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED,gCAAgC,CAC9B,YAAoB,EACpB,UAAc;QAEd,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,SAAS,CAAC,YAAoB;QAC5B,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,kBAAkB,CAAC,OAAqB;QACtC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,cAAc,CAAC,WAAe;QAC5B,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;IAED,UAAU;QACR,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,QAAQ,CACN,WAAe,EACf,UAAkB,EAClB,eAAyB,EACzB,eAAyB,EACzB,eAAyB,EACzB,YAAkB,EAClB,iBAA2B,EAC3B,aAAuB,EACvB,aAAuB,EACvB,aAAuB,EACvB,SAAmB,EACnB,KAAa,EACb,MAAc,EACd,OAAmB;QAEnB,6DAA6D;QAC7D,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QAEhF,MAAM,KAAK,GAAG,SAAS,CAAW,YAAY,EAAE;YAC9C,OAAO,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC/D,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE;gBAC3E,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC;gBACtB,UAAU,EAAE,iBAAiB,CAAC,CAAC,CAAC;aACjC,CAAC,CAAC;YACH,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBACtC,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE;gBACvE,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;aACpB,CAAC,CAAC;YACH,KAAK;YACL,MAAM;SACP,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,aAAa,KAAK,CAAC,MAAM,cAAc,IAAI,CAAC,eAAe,OAAO,WAAW,KAAK,KAAK;aACpF,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;aACpF,IAAI,CAAC,IAAI,CAAC,EAAE,CAChB,CAAC;QAEF,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,iBAAiB,CAAC,WAAe,EAAE,UAAwB,EAAE,SAAe,EAAE,aAAiB,EAAE,OAAe;QAC9G,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;QACjC,IAAI,CAAC,SAAS,CAAC,UAAU,CACvB;YACE,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,WAAW;YACX,KAAK,EAAE,EAAE,CAAC,IAAI,EAAE,kDAAkD;YAClE,IAAI;YACJ,eAAe,EAAE,SAAS,EAAE,2DAA2D;YACvF,aAAa;SACd,EACD,OAAO,CACR,CAAC;QACF,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,mBAAmB,CAAC,cAAkB,EAAE,aAAiB,EAAE,QAAgB;QACzE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,EAAE,cAAc,EAAE,aAAa,CAAC,CAAC;QAChF,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,cAAkB;QAC3C,MAAM,SAAS,GAAG,aAAa,CAAC,IAAI,CAAC,eAAe,EAAE,cAAe,CAAC,CAAC;QACvE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,aAAa,CAAC,YAAY,CAAC,cAAc,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxF,OAAO,KAAK,KAAK,SAAS,CAAC;IAC7B,CAAC;IAED,0BAA0B,CACxB,gBAA8B,EAC9B,YAAgB,EAChB,OAAW;QAEX,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,IAAQ,EAAE,MAAU;QAC7C,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjC,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,6BAA6B,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YAErG,MAAM,aAAa,GAAG,MAAM,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;YAC9F,IAAI,CAAC,aAAa,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;gBACpD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;gBACrB,SAAS;YACX,CAAC;YAED,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,CAAC,eAAe,CACxC,YAAY,CAAC,gBAAgB,EAC7B,aAAa,CAAC,KAAK,CACpB,CAA+B,CAAC;YAEjC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,WAAW,CACf,eAAmB,EACnB,gBAAoB,EACpB,WAAmB,EACnB,gBAAwB;QAExB,MAAM,EAAE,GACN,WAAW,KAAK,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAC3C,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;YACvB,CAAC,CAAC,IAAI,kCAAkC,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAEtE,MAAM,MAAM,GAAG,EAAE,CAAC;QAClB,KAAK,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,gBAAgB,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,MAAM,QAAQ,GAAG,6BAA6B,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC;YAExF,MAAM,aAAa,GAAG,MAAM,EAAE,CAAC,qBAAqB,CAAC,YAAY,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;YAE9F,IAAI,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC;YACpB,IAAI,aAAa,IAAI,aAAa,CAAC,cAAc,EAAE,CAAC;gBAClD,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,CAAC,eAAe,CACxC,YAAY,CAAC,gBAAgB,EAC7B,aAAa,CAAC,KAAK,CACpB,CAA+B,CAAC;gBACjC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;YACzB,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,6BAA6B,WAAW,CAAC,QAAQ,EAAE,UAAU,KAAK,EAAE,CAAC,CAAC;YACxF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,gBAAoB,EAAE,MAAY;QACnD,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjC,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YAC/C,MAAM,WAAW,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,WAAW,CAAC,QAAQ,EAAE,UAAU,KAAK,EAAE,CAAC,CAAC;YACzF,OAAO,IAAI,eAAe,CAAC,6BAA6B,CAAC,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC;QACtG,CAAC,CAAC,CAAC;QACH,MAAM,EAAE,CAAC,WAAW,CAClB,YAAY,CAAC,gBAAgB,EAC7B,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE,CAAC,EACjG,0BAA0B,CAC3B,CAAC;QACF,OAAO,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,gBAAgB,CAAC,gBAA8B,EAAE,WAAe,EAAE,cAAsB,EAAE,QAAgB;QACxG,OAAO;IACT,CAAC;IAED,oBAAoB,CAAC,gBAAwB,EAAE,cAAsB,EAAE,QAAgB;QACrF,OAAO;IACT,CAAC;IAED,uBAAuB,CACrB,eAA6B,EAC7B,WAAe,EACf,UAAwB,EACxB,MAA4B,EAC5B,KAAY,EACZ,QAAc;QAEd,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QACxF,MAAM,UAAU,GAAG,IAAI,SAAS,CAAC,aAAa,CAAC,CAAC;QAEhD,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,CAAC;QAEtC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC;QAExC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IAED,kBAAkB,CAAC,IAAsB,EAAE,QAAgB;QACzD,OAAO;IACT,CAAC;IAED,+BAA+B,CAAC,IAAsB,EAAE,QAAgB;QACtE,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,mBAAmB,CACvB,qBAAmC,EACnC,gBAAkC,EAClC,QAAY,EACZ,iBAAyB,EACzB,YAAqB,EACrB,cAAuB;QAEvB,IAAI,CAAC,MAAM,CAAC,OAAO,CACjB,+BAA+B,qBAAqB,IAAI,gBAAgB,IAAI,MAAM,IAAI,CAAC,oBAAoB,CACzG,qBAAqB,EACrB,gBAAgB,CACjB,kBAAkB,YAAY,mBAAmB,cAAc,EAAE,CACnE,CAAC;QAEF,uBAAuB;QACvB,MAAM,sBAAsB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5E,MAAM,oBAAoB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;QAC/C,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;QAE3C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,qBAAqB,EAAE,gBAAgB,CAAC,CAAC;QAE5G,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC;QAC/B,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,iBAAiB,CACjD,QAAQ,EACR,QAAQ,EACR,iBAAiB,EACjB,YAAY,EACZ,cAAc,CACf,CAAC;QACF,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;QAC1B,IAAI,CAAC;YACH,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,GAAU,EAAE,EAAE;gBAC9F,MAAM,SAAS,GAAG,IAAI,cAAc,CAClC,GAAG,CAAC,OAAO,EACX;oBACE,eAAe,EAAE,qBAAqB;oBACtC,gBAAgB;iBACjB,EACD,gBAAgB,CAAC,GAAG,EAAE,QAAQ,CAAC,KAAK,CAAC,EACrC,EAAE,KAAK,EAAE,GAAG,EAAE,CACf,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oCAAoC,qBAAqB,IAAI,gBAAgB,EAAE,CAAC,CAAC;gBACnG,MAAM,qBAAqB,CAAC,SAAS,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;YACH,MAAM,QAAQ,GAAG,KAAK,CAAC,EAAE,EAAE,CAAC;YAC5B,MAAM,aAAa,GAAG,kBAAkB,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;YAC5E,MAAM,YAAY,GAAG,0BAA0B,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;YAE1E,MAAM,kBAAkB,GAAG,kBAAkB,CAAC,cAAc,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,aAAa,CAAC;YACxF,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,qBAAqB,CAAC,QAAQ,EAAE,IAAI,gBAAgB,EAAE,EAAE;gBACjG,WAAW,EAAE,aAAa;gBAC1B,QAAQ;gBACR,SAAS,EAAE,4BAA4B;gBACvC,SAAS,EAAE,kBAAkB;gBAC7B,UAAU,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM;gBAC1C,cAAc,EAAE,QAAQ;aACe,CAAC,CAAC;YAE3C,MAAM,aAAa,GAAG,IAAI,oBAAoB,CAC5C,qBAAqB,EACrB,IAAI,YAAY,CAAC,gBAAgB,EAAE,IAAI,CAAC,EACxC,YAAY,CACb,CAAC;YACF,qBAAqB;YACrB,IAAI,CAAC,kBAAkB,GAAG,YAAY,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC;YAEvE,MAAM,IAAI,CAAC,aAAa,CACtB,qBAAqB,EACrB,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CACpG,CAAC;YAEF,MAAM,IAAI,CAAC,aAAa,CACtB,qBAAqB,EACrB,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAChG,CAAC;YAEF,OAAO,aAAa,CAAC;QACvB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;YAChD,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;YACxC,IAAI,CAAC,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,iBAAiB,CACrB,GAAgB,EAChB,QAAY,EACZ,iBAAyB,EACzB,YAAqB,EACrB,cAAuB;QAEvB,MAAM,aAAa,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAE9C,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAErD,IAAI,IAAI,CAAC,MAAM,KAAK,aAAa,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC5C,CAAC;QAED,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAC7D,IAAI,CAAC,WAAW,GAAG,CAAC,EACpB,iBAAiB,EACjB,YAAY,EACZ,cAAc,CACf,CAAC;QAEF,MAAM,MAAM,GAAG,CAAC,GAAG,oBAAoB,CAAC,QAAQ,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;QAE7D,OAAO,aAAa,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAClC,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAAC,OAAqB,EAAE,QAA0B;QACjF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,QAAS,CAAC,eAAe,CAAC,CAAC;QAC9F,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,MAAM,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CACpC,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAC9E,CAAC;QACF,IAAI,CAAC,CAAC,EAAE,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,GAAG,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,qBAAqB,CACzB,qBAAmC,EACnC,gBAAkC,EAClC,IAAU,EACV,WAAwB;QAExB,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;QAC9B,MAAM,CAAC,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACxD,MAAM,CAAC,eAAe,CAAC,WAAW,GAAG,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QACzE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU,CACrD,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CACvE,CAAC;QACF,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU,CACpD,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CACvE,CAAC;QACF,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU,CACtD,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CACzE,CAAC;QACF,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,GAAG,EAAE,CAAC,UAAU,CACjD,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAC9E,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,cAAc,CACjC,IAAI,gBAAgB,CAAC,IAAI,CAAC,EAC1B,IAAI,2BAA2B,CAAC,IAAI,2BAA2B,CAAC,IAAI,CAAC,CAAC,EACtE,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,EACvC,MAAM,CACP,CAAC;QACF,MAAM,SAAS,GAAG;YAChB,eAAe,EAAE,qBAAqB;YACtC,gBAAgB;YAChB,IAAI;YACJ,WAAW;SACZ,CAAC;QAEF,OAAO,QAAQ,CAAC,QAAQ,CACtB,SAAS,EACT,eAAe,CAAC,KAAK,EAAE,EACvB,GAAG,CAAC,IAAI,EAAE,EACV,SAAS,CAAC,KAAK,EAAE;QACjB,uBAAuB,CAAC,EAAE;QAC1B,oBAAoB,CAAC,EAAE,CAAC,GAAG,CAC5B,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,aAAa,CACjB,qBAAmC,EACnC,gBAAkC,EAClC,IAAU,EACV,YAAqB,EACrB,cAAuB;QAEvB,uBAAuB;QACvB,MAAM,sBAAsB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5E,MAAM,oBAAoB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;QAC/C,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;QAE3C,MAAM,WAAW,GAAG,WAAW,CAAC,KAAK,EAAE,CAAC;QACxC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACvC,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACrD,WAAW,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QAC3D,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC;QACxC,WAAW,CAAC,cAAc,GAAG,cAAc,CAAC;QAE5C,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,qBAAqB,CACtD,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,EACJ,WAAW,CACZ,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,kBAAkB,IAAI,eAAe,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC;QAC7E,CAAC;QACD,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;QAChD,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QACxC,IAAI,CAAC,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;QAElD,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,KAAK,CAAC,kBAAkB,CACtB,qBAAmC,EACnC,gBAAkC,EAClC,QAAY,EACZ,iBAAyB,EACzB,YAAqB,EACrB,cAAuB;QAEvB,uBAAuB;QACvB,MAAM,sBAAsB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5E,MAAM,oBAAoB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;QAC/C,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;QAE3C,MAAM,WAAW,GAAG,WAAW,CAAC,KAAK,EAAE,CAAC;QACxC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACvC,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACrD,WAAW,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QAC3D,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC;QACxC,WAAW,CAAC,cAAc,GAAG,cAAc,CAAC;QAE5C,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAErD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,qBAAqB,CACtD,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,EACJ,WAAW,CACZ,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,kBAAkB,GAAG,eAAe,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC;QAC1E,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;QAChD,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QACxC,IAAI,CAAC,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;QAElD,OAAO,eAAe,CAAC,YAAY,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,yBAAyB,CAC7B,qBAAmC,EACnC,gBAAkC,EAClC,QAAY,EACZ,iBAAyB,EACzB,YAAqB,EACrB,cAAuB;QAEvB,uBAAuB;QACvB,MAAM,sBAAsB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC5E,MAAM,oBAAoB,GAAG,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,MAAM,uBAAuB,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAC;QAC5F,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACxC,IAAI,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;QAC/C,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;QAE3C,MAAM,WAAW,GAAG,WAAW,CAAC,KAAK,EAAE,CAAC;QACxC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QACvC,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACrD,WAAW,CAAC,sBAAsB,GAAG,qBAAqB,CAAC;QAC3D,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC;QACxC,WAAW,CAAC,cAAc,GAAG,cAAc,CAAC;QAE5C,MAAM,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAErD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,qBAAqB,CACtD,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,EACJ,WAAW,CACZ,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,kBAAkB,IAAI,eAAe,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC;QAC3E,IAAI,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;QAChD,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QACxC,IAAI,CAAC,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;QAElD,MAAM,iBAAiB,GAAG,WAAW,CAAC,KAAK,EAAE,CAAC;QAC9C,iBAAiB,CAAC,SAAS,GAAG,oBAAoB,CAAC;QACnD,iBAAiB,CAAC,gBAAgB,GAAG,uBAAuB,CAAC;QAC7D,iBAAiB,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;QAClE,iBAAiB,CAAC,YAAY,GAAG,YAAY,CAAC;QAC9C,iBAAiB,CAAC,cAAc,GAAG,cAAc,CAAC;QAElD,OAAO,iBAAiB,CAAC,IAAI,CAAC;YAC5B,iBAAiB;YACjB,eAAe,EAAE,qBAAqB;YACtC,gBAAgB;YAChB,WAAW;YACX,iBAAiB;YACjB,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAED,6BAA6B,CAC3B,qBAAmC,EACnC,gBAAkC,EAClC,QAAY,EACZ,iBAAyB,EACzB,YAAqB,EACrB,cAAuB;QAEvB,oEAAoE;QACpE,kCAAkC;QAClC,OAAO,IAAI,CAAC,yBAAyB,CACnC,qBAAqB,EACrB,gBAAgB,EAChB,QAAQ,EACR,iBAAiB,EACjB,YAAY,EACZ,cAAc,CACf,CAAC;IACJ,CAAC;IAED,aAAa,CAAC,KAAa,EAAE,oBAA4B,EAAE,GAAW;QACpE,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QAC5B,OAAO,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,oBAAoB,EAAE,GAAG,CAAC,CAAC;IACnE,CAAC;IAED,QAAQ,CAAC,OAAe,EAAE,MAAY;QACpC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,qBAAqB,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,qBAAqB,CACnB,gBAA8B,EAC9B,WAAe,EACf,eAAuB,EACvB,QAAgB;QAEhB,OAAO;IACT,CAAC;IAED,wBAAwB,CACtB,gBAA8B,EAC9B,WAAe,EACf,YAAgB,EAChB,OAA6B,EAC7B,MAAa,EACb,SAAe;QAEf,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;CACF"}