@synthra-swap/smart-order-router 3.15.0

package/build/module/routers/alpha-router/alpha-router.js

@@ -0,0 +1,846 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import DEFAULT_TOKEN_LIST from '@uniswap/default-token-list';
+import { Protocol, SwapRouter } from '@uniswap/router-sdk';
+import { Pool, Position, SqrtPriceMath, TickMath } from '@uniswap/v3-sdk';
+import { ChainId, Fraction, TradeType, } from '@synthra-swap/sdk-core';
+import retry from 'async-retry';
+import JSBI from 'jsbi';
+import _ from 'lodash';
+import NodeCache from 'node-cache';
+import { CachedRoutes, CacheMode, CachingGasStationProvider, CachingTokenProviderWithFallback, CachingV2PoolProvider, CachingV2SubgraphProvider, CachingV3PoolProvider, CachingV3SubgraphProvider, EIP1559GasPriceProvider, ETHGasStationInfoProvider, LegacyGasPriceProvider, NodeJSCache, OnChainGasPriceProvider, OnChainQuoteProvider, StaticV2SubgraphProvider, StaticV3SubgraphProvider, SwapRouterProvider, UniswapMulticallProvider, URISubgraphProvider, V2QuoteProvider, V2SubgraphProviderWithFallBacks, V3SubgraphProviderWithFallBacks, } from '../../providers';
+import { CachingTokenListProvider, } from '../../providers/caching-token-list-provider';
+import { TokenProvider } from '../../providers/token-provider';
+import { TokenValidatorProvider, } from '../../providers/token-validator-provider';
+import { V2PoolProvider, } from '../../providers/v2/pool-provider';
+import { ArbitrumGasDataProvider, OptimismGasDataProvider, } from '../../providers/v3/gas-data-provider';
+import { V3PoolProvider, } from '../../providers/v3/pool-provider';
+import { Erc20__factory } from '../../types/other/factories/Erc20__factory';
+import { SWAP_ROUTER_02_ADDRESSES, WRAPPED_NATIVE_CURRENCY } from '../../util';
+import { CurrencyAmount } from '../../util/amounts';
+import { ID_TO_CHAIN_ID, ID_TO_NETWORK_NAME, V2_SUPPORTED, } from '../../util/chains';
+import { getHighestLiquidityV3NativePool, getHighestLiquidityV3USDPool, } from '../../util/gas-factory-helpers';
+import { log } from '../../util/log';
+import { buildSwapMethodParameters, buildTrade, } from '../../util/methodParameters';
+import { metric, MetricLoggerUnit } from '../../util/metric';
+import { UNSUPPORTED_TOKENS } from '../../util/unsupported-tokens';
+import { SwapToRatioStatus, } from '../router';
+import { DEFAULT_ROUTING_CONFIG_BY_CHAIN, ETH_GAS_STATION_API_URL, } from './config';
+import { getBestSwapRoute } from './functions/best-swap-route';
+import { calculateRatioAmountIn } from './functions/calculate-ratio-amount-in';
+import { MixedRouteHeuristicGasModelFactory } from './gas-models/mixedRoute/mixed-route-heuristic-gas-model';
+import { V2HeuristicGasModelFactory } from './gas-models/v2/v2-heuristic-gas-model';
+import { V3HeuristicGasModelFactory } from './gas-models/v3/v3-heuristic-gas-model';
+import { MixedQuoter, V2Quoter, V3Quoter } from './quoters';
+export class MapWithLowerCaseKey extends Map {
+    set(key, value) {
+        return super.set(key.toLowerCase(), value);
+    }
+}
+export class AlphaRouter {
+    constructor({ chainId, provider, multicall2Provider, v3PoolProvider, onChainQuoteProvider, v2PoolProvider, v2QuoteProvider, v2SubgraphProvider, tokenProvider, blockedTokenListProvider, v3SubgraphProvider, gasPriceProvider, v3GasModelFactory, v2GasModelFactory, mixedRouteGasModelFactory, swapRouterProvider, optimismGasDataProvider, tokenValidatorProvider, arbitrumGasDataProvider, simulator, routeCachingProvider, }) {
+        this.chainId = chainId;
+        this.provider = provider;
+        this.multicall2Provider =
+            multicall2Provider !== null && multicall2Provider !== void 0 ? multicall2Provider : new UniswapMulticallProvider(chainId, provider, 375000);
+        this.v3PoolProvider =
+            v3PoolProvider !== null && v3PoolProvider !== void 0 ? v3PoolProvider : new CachingV3PoolProvider(this.chainId, new V3PoolProvider(ID_TO_CHAIN_ID(chainId), this.multicall2Provider), new NodeJSCache(new NodeCache({ stdTTL: 360, useClones: false })));
+        this.simulator = simulator;
+        this.routeCachingProvider = routeCachingProvider;
+        if (onChainQuoteProvider) {
+            this.onChainQuoteProvider = onChainQuoteProvider;
+        }
+        else {
+            switch (chainId) {
+                case ChainId.OPTIMISM:
+                case ChainId.OPTIMISM_GOERLI:
+                case ChainId.BASE:
+                case ChainId.BASE_GOERLI:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, {
+                        multicallChunk: 110,
+                        gasLimitPerCall: 1200000,
+                        quoteMinSuccessRate: 0.1,
+                    }, {
+                        gasLimitOverride: 3000000,
+                        multicallChunk: 45,
+                    }, {
+                        gasLimitOverride: 3000000,
+                        multicallChunk: 45,
+                    }, {
+                        baseBlockOffset: -10,
+                        rollback: {
+                            enabled: true,
+                            attemptsBeforeRollback: 1,
+                            rollbackBlockOffset: -10,
+                        },
+                    });
+                    break;
+                case ChainId.ARBITRUM_ONE:
+                case ChainId.ARBITRUM_GOERLI:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, {
+                        multicallChunk: 10,
+                        gasLimitPerCall: 12000000,
+                        quoteMinSuccessRate: 0.1,
+                    }, {
+                        gasLimitOverride: 30000000,
+                        multicallChunk: 6,
+                    }, {
+                        gasLimitOverride: 30000000,
+                        multicallChunk: 6,
+                    });
+                    break;
+                case ChainId.CELO:
+                case ChainId.CELO_ALFAJORES:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, {
+                        multicallChunk: 10,
+                        gasLimitPerCall: 5000000,
+                        quoteMinSuccessRate: 0.1,
+                    }, {
+                        gasLimitOverride: 5000000,
+                        multicallChunk: 5,
+                    }, {
+                        gasLimitOverride: 6250000,
+                        multicallChunk: 4,
+                    });
+                    break;
+                default:
+                    this.onChainQuoteProvider = new OnChainQuoteProvider(chainId, provider, this.multicall2Provider, {
+                        retries: 2,
+                        minTimeout: 100,
+                        maxTimeout: 1000,
+                    }, {
+                        multicallChunk: 210,
+                        gasLimitPerCall: 705000,
+                        quoteMinSuccessRate: 0.15,
+                    }, {
+                        gasLimitOverride: 2000000,
+                        multicallChunk: 70,
+                    });
+                    break;
+            }
+        }
+        this.v2PoolProvider =
+            v2PoolProvider !== null && v2PoolProvider !== void 0 ? v2PoolProvider : new CachingV2PoolProvider(chainId, new V2PoolProvider(chainId, this.multicall2Provider), new NodeJSCache(new NodeCache({ stdTTL: 60, useClones: false })));
+        this.v2QuoteProvider = v2QuoteProvider !== null && v2QuoteProvider !== void 0 ? v2QuoteProvider : new V2QuoteProvider();
+        this.blockedTokenListProvider =
+            blockedTokenListProvider !== null && blockedTokenListProvider !== void 0 ? blockedTokenListProvider : new CachingTokenListProvider(chainId, UNSUPPORTED_TOKENS, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false })));
+        this.tokenProvider =
+            tokenProvider !== null && tokenProvider !== void 0 ? tokenProvider : new CachingTokenProviderWithFallback(chainId, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false })), new CachingTokenListProvider(chainId, DEFAULT_TOKEN_LIST, new NodeJSCache(new NodeCache({ stdTTL: 3600, useClones: false }))), new TokenProvider(chainId, this.multicall2Provider));
+        const chainName = ID_TO_NETWORK_NAME(chainId);
+        // ipfs urls in the following format: `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/${protocol}/${chainName}.json`;
+        if (v2SubgraphProvider) {
+            this.v2SubgraphProvider = v2SubgraphProvider;
+        }
+        else {
+            this.v2SubgraphProvider = new V2SubgraphProviderWithFallBacks([
+                new CachingV2SubgraphProvider(chainId, new URISubgraphProvider(chainId, `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/v2/${chainName}.json`, undefined, 0), new NodeJSCache(new NodeCache({ stdTTL: 300, useClones: false }))),
+                new StaticV2SubgraphProvider(chainId),
+            ]);
+        }
+        if (v3SubgraphProvider) {
+            this.v3SubgraphProvider = v3SubgraphProvider;
+        }
+        else {
+            this.v3SubgraphProvider = new V3SubgraphProviderWithFallBacks([
+                new CachingV3SubgraphProvider(chainId, new URISubgraphProvider(chainId, `https://cloudflare-ipfs.com/ipns/api.uniswap.org/v1/pools/v3/${chainName}.json`, undefined, 0), new NodeJSCache(new NodeCache({ stdTTL: 300, useClones: false }))),
+                new StaticV3SubgraphProvider(chainId, this.v3PoolProvider),
+            ]);
+        }
+        let gasPriceProviderInstance;
+        if (JsonRpcProvider.isProvider(this.provider)) {
+            gasPriceProviderInstance = new OnChainGasPriceProvider(chainId, new EIP1559GasPriceProvider(this.provider), new LegacyGasPriceProvider(this.provider));
+        }
+        else {
+            gasPriceProviderInstance = new ETHGasStationInfoProvider(ETH_GAS_STATION_API_URL);
+        }
+        this.gasPriceProvider =
+            gasPriceProvider !== null && gasPriceProvider !== void 0 ? gasPriceProvider : new CachingGasStationProvider(chainId, gasPriceProviderInstance, new NodeJSCache(new NodeCache({ stdTTL: 7, useClones: false })));
+        this.v3GasModelFactory =
+            v3GasModelFactory !== null && v3GasModelFactory !== void 0 ? v3GasModelFactory : new V3HeuristicGasModelFactory();
+        this.v2GasModelFactory =
+            v2GasModelFactory !== null && v2GasModelFactory !== void 0 ? v2GasModelFactory : new V2HeuristicGasModelFactory();
+        this.mixedRouteGasModelFactory =
+            mixedRouteGasModelFactory !== null && mixedRouteGasModelFactory !== void 0 ? mixedRouteGasModelFactory : new MixedRouteHeuristicGasModelFactory();
+        this.swapRouterProvider =
+            swapRouterProvider !== null && swapRouterProvider !== void 0 ? swapRouterProvider : new SwapRouterProvider(this.multicall2Provider, this.chainId);
+        if (chainId === ChainId.OPTIMISM || chainId === ChainId.BASE) {
+            this.l2GasDataProvider =
+                optimismGasDataProvider !== null && optimismGasDataProvider !== void 0 ? optimismGasDataProvider : new OptimismGasDataProvider(chainId, this.multicall2Provider);
+        }
+        if (chainId === ChainId.ARBITRUM_ONE ||
+            chainId === ChainId.ARBITRUM_GOERLI) {
+            this.l2GasDataProvider =
+                arbitrumGasDataProvider !== null && arbitrumGasDataProvider !== void 0 ? arbitrumGasDataProvider : new ArbitrumGasDataProvider(chainId, this.provider);
+        }
+        if (tokenValidatorProvider) {
+            this.tokenValidatorProvider = tokenValidatorProvider;
+        }
+        else if (this.chainId === ChainId.MAINNET) {
+            this.tokenValidatorProvider = new TokenValidatorProvider(this.chainId, this.multicall2Provider, new NodeJSCache(new NodeCache({ stdTTL: 30000, useClones: false })));
+        }
+        // Initialize the Quoters.
+        // Quoters are an abstraction encapsulating the business logic of fetching routes and quotes.
+        this.v2Quoter = new V2Quoter(this.v2SubgraphProvider, this.v2PoolProvider, this.v2QuoteProvider, this.v2GasModelFactory, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+        this.v3Quoter = new V3Quoter(this.v3SubgraphProvider, this.v3PoolProvider, this.onChainQuoteProvider, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+        this.mixedQuoter = new MixedQuoter(this.v3SubgraphProvider, this.v3PoolProvider, this.v2SubgraphProvider, this.v2PoolProvider, this.onChainQuoteProvider, this.tokenProvider, this.chainId, this.blockedTokenListProvider, this.tokenValidatorProvider);
+    }
+    async routeToRatio(token0Balance, token1Balance, position, swapAndAddConfig, swapAndAddOptions, routingConfig = DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId)) {
+        if (token1Balance.currency.wrapped.sortsBefore(token0Balance.currency.wrapped)) {
+            [token0Balance, token1Balance] = [token1Balance, token0Balance];
+        }
+        let preSwapOptimalRatio = this.calculateOptimalRatio(position, position.pool.sqrtRatioX96, true);
+        // set up parameters according to which token will be swapped
+        let zeroForOne;
+        if (position.pool.tickCurrent > position.tickUpper) {
+            zeroForOne = true;
+        }
+        else if (position.pool.tickCurrent < position.tickLower) {
+            zeroForOne = false;
+        }
+        else {
+            zeroForOne = new Fraction(token0Balance.quotient, token1Balance.quotient).greaterThan(preSwapOptimalRatio);
+            if (!zeroForOne)
+                preSwapOptimalRatio = preSwapOptimalRatio.invert();
+        }
+        const [inputBalance, outputBalance] = zeroForOne
+            ? [token0Balance, token1Balance]
+            : [token1Balance, token0Balance];
+        let optimalRatio = preSwapOptimalRatio;
+        let postSwapTargetPool = position.pool;
+        let exchangeRate = zeroForOne
+            ? position.pool.token0Price
+            : position.pool.token1Price;
+        let swap = null;
+        let ratioAchieved = false;
+        let n = 0;
+        // iterate until we find a swap with a sufficient ratio or return null
+        while (!ratioAchieved) {
+            n++;
+            if (n > swapAndAddConfig.maxIterations) {
+                log.info('max iterations exceeded');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'max iterations exceeded',
+                };
+            }
+            const amountToSwap = calculateRatioAmountIn(optimalRatio, exchangeRate, inputBalance, outputBalance);
+            if (amountToSwap.equalTo(0)) {
+                log.info(`no swap needed: amountToSwap = 0`);
+                return {
+                    status: SwapToRatioStatus.NO_SWAP_NEEDED,
+                };
+            }
+            swap = await this.route(amountToSwap, outputBalance.currency, TradeType.EXACT_INPUT, undefined, {
+                ...DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId),
+                ...routingConfig,
+                /// @dev We do not want to query for mixedRoutes for routeToRatio as they are not supported
+                /// [Protocol.V3, Protocol.V2] will make sure we only query for V3 and V2
+                protocols: [Protocol.V3 /* Protocol.V2 */],
+            });
+            if (!swap) {
+                log.info('no route found from this.route()');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'no route found',
+                };
+            }
+            const inputBalanceUpdated = inputBalance.subtract(swap.trade.inputAmount);
+            const outputBalanceUpdated = outputBalance.add(swap.trade.outputAmount);
+            const newRatio = inputBalanceUpdated.divide(outputBalanceUpdated);
+            let targetPoolPriceUpdate;
+            swap.route.forEach((route) => {
+                if (route.protocol === Protocol.V3) {
+                    const v3Route = route;
+                    v3Route.route.pools.forEach((pool, i) => {
+                        if (pool.token0.equals(position.pool.token0) &&
+                            pool.token1.equals(position.pool.token1) &&
+                            pool.fee === position.pool.fee) {
+                            targetPoolPriceUpdate = JSBI.BigInt(v3Route.sqrtPriceX96AfterList[i].toString());
+                            optimalRatio = this.calculateOptimalRatio(position, JSBI.BigInt(targetPoolPriceUpdate.toString()), zeroForOne);
+                        }
+                    });
+                }
+            });
+            if (!targetPoolPriceUpdate) {
+                optimalRatio = preSwapOptimalRatio;
+            }
+            ratioAchieved =
+                newRatio.equalTo(optimalRatio) ||
+                    this.absoluteValue(newRatio.asFraction.divide(optimalRatio).subtract(1)).lessThan(swapAndAddConfig.ratioErrorTolerance);
+            if (ratioAchieved && targetPoolPriceUpdate) {
+                postSwapTargetPool = new Pool(position.pool.token0, position.pool.token1, position.pool.fee, targetPoolPriceUpdate, position.pool.liquidity, TickMath.getTickAtSqrtRatio(targetPoolPriceUpdate), position.pool.tickDataProvider);
+            }
+            exchangeRate = swap.trade.outputAmount.divide(swap.trade.inputAmount);
+            log.info({
+                exchangeRate: exchangeRate.asFraction.toFixed(18),
+                optimalRatio: optimalRatio.asFraction.toFixed(18),
+                newRatio: newRatio.asFraction.toFixed(18),
+                inputBalanceUpdated: inputBalanceUpdated.asFraction.toFixed(18),
+                outputBalanceUpdated: outputBalanceUpdated.asFraction.toFixed(18),
+                ratioErrorTolerance: swapAndAddConfig.ratioErrorTolerance.toFixed(18),
+                iterationN: n.toString(),
+            }, 'QuoteToRatio Iteration Parameters');
+            if (exchangeRate.equalTo(0)) {
+                log.info('exchangeRate to 0');
+                return {
+                    status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                    error: 'insufficient liquidity to swap to optimal ratio',
+                };
+            }
+        }
+        if (!swap) {
+            return {
+                status: SwapToRatioStatus.NO_ROUTE_FOUND,
+                error: 'no route found',
+            };
+        }
+        let methodParameters;
+        if (swapAndAddOptions) {
+            methodParameters = await this.buildSwapAndAddMethodParameters(swap.trade, swapAndAddOptions, {
+                initialBalanceTokenIn: inputBalance,
+                initialBalanceTokenOut: outputBalance,
+                preLiquidityPosition: position,
+            });
+        }
+        return {
+            status: SwapToRatioStatus.SUCCESS,
+            result: { ...swap, methodParameters, optimalRatio, postSwapTargetPool },
+        };
+    }
+    /**
+     * @inheritdoc IRouter
+     */
+    async route(amount, quoteCurrency, tradeType, swapConfig, partialRoutingConfig = {}) {
+        var _a, _c, _d;
+        const { currencyIn, currencyOut } = this.determineCurrencyInOutFromTradeType(tradeType, amount, quoteCurrency);
+        const tokenIn = currencyIn.wrapped;
+        const tokenOut = currencyOut.wrapped;
+        metric.setProperty('chainId', this.chainId);
+        metric.setProperty('pair', `${tokenIn.symbol}/${tokenOut.symbol}`);
+        metric.setProperty('tokenIn', tokenIn.address);
+        metric.setProperty('tokenOut', tokenOut.address);
+        metric.setProperty('tradeType', tradeType === TradeType.EXACT_INPUT ? 'ExactIn' : 'ExactOut');
+        metric.putMetric(`QuoteRequestedForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+        // Get a block number to specify in all our calls. Ensures data we fetch from chain is
+        // from the same block.
+        const blockNumber = (_a = partialRoutingConfig.blockNumber) !== null && _a !== void 0 ? _a : this.getBlockNumberPromise();
+        const routingConfig = _.merge({}, DEFAULT_ROUTING_CONFIG_BY_CHAIN(this.chainId), partialRoutingConfig, { blockNumber });
+        const gasPriceWei = await this.getGasPriceWei();
+        const quoteToken = quoteCurrency.wrapped;
+        const [v3GasModel, mixedRouteGasModel] = await this.getGasModels(gasPriceWei, amount.currency.wrapped, quoteToken, { blockNumber });
+        // Create a Set to sanitize the protocols input, a Set of undefined becomes an empty set,
+        // Then create an Array from the values of that Set.
+        const protocols = Array.from(new Set(routingConfig.protocols).values());
+        const cacheMode = await ((_c = this.routeCachingProvider) === null || _c === void 0 ? void 0 : _c.getCacheMode(this.chainId, amount, quoteToken, tradeType, protocols));
+        // Fetch CachedRoutes
+        let cachedRoutes;
+        if (cacheMode !== CacheMode.Darkmode) {
+            cachedRoutes = await ((_d = this.routeCachingProvider) === null || _d === void 0 ? void 0 : _d.getCachedRoute(this.chainId, amount, quoteToken, tradeType, protocols, await blockNumber));
+        }
+        if (cacheMode && cacheMode !== CacheMode.Darkmode && !cachedRoutes) {
+            metric.putMetric(`GetCachedRoute_miss_${cacheMode}`, 1, MetricLoggerUnit.Count);
+            log.info({
+                tokenIn: tokenIn.symbol,
+                tokenInAddress: tokenIn.address,
+                tokenOut: tokenOut.symbol,
+                tokenOutAddress: tokenOut.address,
+                cacheMode,
+                amount: amount.toExact(),
+                chainId: this.chainId,
+                tradeType: this.tradeTypeStr(tradeType),
+            }, `GetCachedRoute miss ${cacheMode} for ${this.tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType)}`);
+        }
+        else if (cachedRoutes) {
+            metric.putMetric(`GetCachedRoute_hit_${cacheMode}`, 1, MetricLoggerUnit.Count);
+            log.info({
+                tokenIn: tokenIn.symbol,
+                tokenInAddress: tokenIn.address,
+                tokenOut: tokenOut.symbol,
+                tokenOutAddress: tokenOut.address,
+                cacheMode,
+                amount: amount.toExact(),
+                chainId: this.chainId,
+                tradeType: this.tradeTypeStr(tradeType),
+            }, `GetCachedRoute hit ${cacheMode} for ${this.tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType)}`);
+        }
+        let swapRouteFromCachePromise = Promise.resolve(null);
+        if (cachedRoutes) {
+            swapRouteFromCachePromise = this.getSwapRouteFromCache(cachedRoutes, await blockNumber, amount, quoteToken, tradeType, routingConfig, v3GasModel, mixedRouteGasModel, gasPriceWei);
+        }
+        let swapRouteFromChainPromise = Promise.resolve(null);
+        if (!cachedRoutes || cacheMode !== CacheMode.Livemode) {
+            swapRouteFromChainPromise = this.getSwapRouteFromChain(amount, tokenIn, tokenOut, protocols, quoteToken, tradeType, routingConfig, v3GasModel, mixedRouteGasModel, gasPriceWei);
+        }
+        const [swapRouteFromCache, swapRouteFromChain] = await Promise.all([
+            swapRouteFromCachePromise,
+            swapRouteFromChainPromise,
+        ]);
+        let swapRouteRaw;
+        if (cacheMode === CacheMode.Livemode && swapRouteFromCache) {
+            log.info(`CacheMode is ${cacheMode}, and we are using swapRoute from cache`);
+            swapRouteRaw = swapRouteFromCache;
+        }
+        else {
+            log.info(`CacheMode is ${cacheMode}, and we are using materialized swapRoute`);
+            swapRouteRaw = swapRouteFromChain;
+        }
+        if (cacheMode === CacheMode.Tapcompare &&
+            swapRouteFromCache &&
+            swapRouteFromChain) {
+            const quoteDiff = swapRouteFromChain.quote.subtract(swapRouteFromCache.quote);
+            const quoteGasAdjustedDiff = swapRouteFromChain.quoteGasAdjusted.subtract(swapRouteFromCache.quoteGasAdjusted);
+            const gasUsedDiff = swapRouteFromChain.estimatedGasUsed.sub(swapRouteFromCache.estimatedGasUsed);
+            // Only log if quoteDiff is different from 0, or if quoteGasAdjustedDiff and gasUsedDiff are both different from 0
+            if (!quoteDiff.equalTo(0) ||
+                !(quoteGasAdjustedDiff.equalTo(0) || gasUsedDiff.eq(0))) {
+                // Calculates the percentage of the difference with respect to the quoteFromChain (not from cache)
+                const misquotePercent = quoteGasAdjustedDiff
+                    .divide(swapRouteFromChain.quoteGasAdjusted)
+                    .multiply(100);
+                metric.putMetric(`TapcompareCachedRoute_quoteGasAdjustedDiffPercent`, Number(misquotePercent.toExact()), MetricLoggerUnit.Percent);
+                log.warn({
+                    quoteFromChain: swapRouteFromChain.quote.toExact(),
+                    quoteFromCache: swapRouteFromCache.quote.toExact(),
+                    quoteDiff: quoteDiff.toExact(),
+                    quoteGasAdjustedFromChain: swapRouteFromChain.quoteGasAdjusted.toExact(),
+                    quoteGasAdjustedFromCache: swapRouteFromCache.quoteGasAdjusted.toExact(),
+                    quoteGasAdjustedDiff: quoteGasAdjustedDiff.toExact(),
+                    gasUsedFromChain: swapRouteFromChain.estimatedGasUsed.toString(),
+                    gasUsedFromCache: swapRouteFromCache.estimatedGasUsed.toString(),
+                    gasUsedDiff: gasUsedDiff.toString(),
+                    routesFromChain: swapRouteFromChain.routes.toString(),
+                    routesFromCache: swapRouteFromCache.routes.toString(),
+                    amount: amount.toExact(),
+                    originalAmount: cachedRoutes === null || cachedRoutes === void 0 ? void 0 : cachedRoutes.originalAmount,
+                    pair: this.tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType),
+                    blockNumber,
+                }, `Comparing quotes between Chain and Cache for ${this.tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType)}`);
+            }
+        }
+        if (!swapRouteRaw) {
+            return null;
+        }
+        const { quote, quoteGasAdjusted, estimatedGasUsed, routes: routeAmounts, estimatedGasUsedQuoteToken, estimatedGasUsedUSD, } = swapRouteRaw;
+        if (this.routeCachingProvider &&
+            cacheMode !== CacheMode.Darkmode &&
+            swapRouteFromChain) {
+            // Generate the object to be cached
+            const routesToCache = CachedRoutes.fromRoutesWithValidQuotes(swapRouteFromChain.routes, this.chainId, tokenIn, tokenOut, protocols.sort(), // sort it for consistency in the order of the protocols.
+            await blockNumber, tradeType, amount.toExact());
+            if (routesToCache) {
+                // Attempt to insert the entry in cache. This is fire and forget promise.
+                // The catch method will prevent any exception from blocking the normal code execution.
+                this.routeCachingProvider
+                    .setCachedRoute(routesToCache, amount)
+                    .then((success) => {
+                    const status = success ? 'success' : 'rejected';
+                    metric.putMetric(`SetCachedRoute_${status}`, 1, MetricLoggerUnit.Count);
+                })
+                    .catch((reason) => {
+                    log.error({
+                        reason: reason,
+                        tokenPair: this.tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType),
+                    }, `SetCachedRoute failure`);
+                    metric.putMetric(`SetCachedRoute_failure`, 1, MetricLoggerUnit.Count);
+                });
+            }
+        }
+        metric.putMetric(`QuoteFoundForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+        // Build Trade object that represents the optimal swap.
+        const trade = buildTrade(currencyIn, currencyOut, tradeType, routeAmounts);
+        let methodParameters;
+        // If user provided recipient, deadline etc. we also generate the calldata required to execute
+        // the swap and return it too.
+        if (swapConfig) {
+            methodParameters = buildSwapMethodParameters(trade, swapConfig, this.chainId);
+        }
+        const swapRoute = {
+            quote,
+            quoteGasAdjusted,
+            estimatedGasUsed,
+            estimatedGasUsedQuoteToken,
+            estimatedGasUsedUSD,
+            gasPriceWei,
+            route: routeAmounts,
+            trade,
+            methodParameters,
+            blockNumber: BigNumber.from(await blockNumber),
+        };
+        if (swapConfig &&
+            swapConfig.simulate &&
+            methodParameters &&
+            methodParameters.calldata) {
+            if (!this.simulator) {
+                throw new Error('Simulator not initialized!');
+            }
+            log.info({ swapConfig, methodParameters }, 'Starting simulation');
+            const fromAddress = swapConfig.simulate.fromAddress;
+            const beforeSimulate = Date.now();
+            const swapRouteWithSimulation = await this.simulator.simulate(fromAddress, swapConfig, swapRoute, amount, 
+            // Quote will be in WETH even if quoteCurrency is ETH
+            // So we init a new CurrencyAmount object here
+            CurrencyAmount.fromRawAmount(quoteCurrency, quote.quotient.toString()), this.l2GasDataProvider
+                ? await this.l2GasDataProvider.getGasData()
+                : undefined, { blockNumber });
+            metric.putMetric('SimulateTransaction', Date.now() - beforeSimulate, MetricLoggerUnit.Milliseconds);
+            return swapRouteWithSimulation;
+        }
+        return swapRoute;
+    }
+    async getSwapRouteFromCache(cachedRoutes, blockNumber, amount, quoteToken, tradeType, routingConfig, v3GasModel, mixedRouteGasModel, gasPriceWei) {
+        log.info({
+            protocols: cachedRoutes.protocolsCovered,
+            tradeType: cachedRoutes.tradeType,
+            cachedBlockNumber: cachedRoutes.blockNumber,
+            quoteBlockNumber: blockNumber,
+        }, 'Routing across CachedRoute');
+        const quotePromises = [];
+        const v3Routes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.V3);
+        const v2Routes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.V2);
+        const mixedRoutes = cachedRoutes.routes.filter((route) => route.protocol === Protocol.MIXED);
+        let percents;
+        let amounts;
+        if (cachedRoutes.routes.length > 1) {
+            // If we have more than 1 route, we will quote the different percents for it, following the regular process
+            [percents, amounts] = this.getAmountDistribution(amount, routingConfig);
+        }
+        else if (cachedRoutes.routes.length == 1) {
+            [percents, amounts] = [[100], [amount]];
+        }
+        else {
+            // In this case this means that there's no route, so we return null
+            return Promise.resolve(null);
+        }
+        if (v3Routes.length > 0) {
+            const v3RoutesFromCache = v3Routes.map((cachedRoute) => cachedRoute.route);
+            quotePromises.push(this.v3Quoter.getQuotes(v3RoutesFromCache, amounts, percents, quoteToken, tradeType, routingConfig, undefined, v3GasModel));
+        }
+        if (v2Routes.length > 0) {
+            quotePromises.push(
+            // When we fetch the quotes in V2, we are not calling the `onChainProvider` like on v3Routes and mixedRoutes
+            // Instead we are using the reserves in the Pool object, so we need to re-load the current reserves.
+            this.v2Quoter.getRoutesThenQuotes(v2Routes[0].tokenIn, v2Routes[0].tokenOut, amounts, percents, quoteToken, tradeType, routingConfig, undefined, gasPriceWei));
+        }
+        if (mixedRoutes.length > 0) {
+            const mixedRoutesFromCache = mixedRoutes.map((cachedRoute) => cachedRoute.route);
+            quotePromises.push(this.mixedQuoter.getQuotes(mixedRoutesFromCache, amounts, percents, quoteToken, tradeType, routingConfig, undefined, mixedRouteGasModel));
+        }
+        const getQuotesResults = await Promise.all(quotePromises);
+        const allRoutesWithValidQuotes = _.flatMap(getQuotesResults, (quoteResult) => quoteResult.routesWithValidQuotes);
+        return getBestSwapRoute(amount, percents, allRoutesWithValidQuotes, tradeType, this.chainId, routingConfig, v3GasModel);
+    }
+    async getSwapRouteFromChain(amount, tokenIn, tokenOut, protocols, quoteToken, tradeType, routingConfig, v3GasModel, mixedRouteGasModel, gasPriceWei) {
+        // Generate our distribution of amounts, i.e. fractions of the input amount.
+        // We will get quotes for fractions of the input amount for different routes, then
+        // combine to generate split routes.
+        const [percents, amounts] = this.getAmountDistribution(amount, routingConfig);
+        const noProtocolsSpecified = protocols.length === 0;
+        const v3ProtocolSpecified = protocols.includes(Protocol.V3);
+        const v2ProtocolSpecified = protocols.includes(Protocol.V2);
+        const v2SupportedInChain = V2_SUPPORTED.includes(this.chainId);
+        const shouldQueryMixedProtocol = protocols.includes(Protocol.MIXED) ||
+            (noProtocolsSpecified && v2SupportedInChain);
+        const mixedProtocolAllowed = [ChainId.MAINNET, ChainId.GOERLI].includes(this.chainId) &&
+            tradeType === TradeType.EXACT_INPUT;
+        const quotePromises = [];
+        // Maybe Quote V3 - if V3 is specified, or no protocol is specified
+        if (v3ProtocolSpecified || noProtocolsSpecified) {
+            log.info({ protocols, tradeType }, 'Routing across V3');
+            quotePromises.push(this.v3Quoter.getRoutesThenQuotes(tokenIn, tokenOut, amounts, percents, quoteToken, tradeType, routingConfig, v3GasModel));
+        }
+        // Maybe Quote V2 - if V2 is specified, or no protocol is specified AND v2 is supported in this chain
+        if (v2SupportedInChain && (v2ProtocolSpecified || noProtocolsSpecified)) {
+            log.info({ protocols, tradeType }, 'Routing across V2');
+            quotePromises.push(this.v2Quoter.getRoutesThenQuotes(tokenIn, tokenOut, amounts, percents, quoteToken, tradeType, routingConfig, undefined, gasPriceWei));
+        }
+        // Maybe Quote mixed routes
+        // if MixedProtocol is specified or no protocol is specified and v2 is supported AND tradeType is ExactIn
+        // AND is Mainnet or Gorli
+        if (shouldQueryMixedProtocol && mixedProtocolAllowed) {
+            log.info({ protocols, tradeType }, 'Routing across MixedRoutes');
+            quotePromises.push(this.mixedQuoter.getRoutesThenQuotes(tokenIn, tokenOut, amounts, percents, quoteToken, tradeType, routingConfig, mixedRouteGasModel));
+        }
+        const getQuotesResults = await Promise.all(quotePromises);
+        const allRoutesWithValidQuotes = [];
+        const allCandidatePools = [];
+        getQuotesResults.forEach((getQuoteResult) => {
+            allRoutesWithValidQuotes.push(...getQuoteResult.routesWithValidQuotes);
+            if (getQuoteResult.candidatePools) {
+                allCandidatePools.push(getQuoteResult.candidatePools);
+            }
+        });
+        if (allRoutesWithValidQuotes.length === 0) {
+            log.info({ allRoutesWithValidQuotes }, 'Received no valid quotes');
+            return null;
+        }
+        // Given all the quotes for all the amounts for all the routes, find the best combination.
+        const bestSwapRoute = await getBestSwapRoute(amount, percents, allRoutesWithValidQuotes, tradeType, this.chainId, routingConfig, v3GasModel);
+        if (bestSwapRoute) {
+            this.emitPoolSelectionMetrics(bestSwapRoute, allCandidatePools);
+        }
+        return bestSwapRoute;
+    }
+    tradeTypeStr(tradeType) {
+        return tradeType === TradeType.EXACT_INPUT ? 'ExactIn' : 'ExactOut';
+    }
+    tokenPairSymbolTradeTypeChainId(tokenIn, tokenOut, tradeType) {
+        return `${tokenIn.symbol}/${tokenOut.symbol}/${this.tradeTypeStr(tradeType)}/${this.chainId}`;
+    }
+    determineCurrencyInOutFromTradeType(tradeType, amount, quoteCurrency) {
+        if (tradeType === TradeType.EXACT_INPUT) {
+            return {
+                currencyIn: amount.currency,
+                currencyOut: quoteCurrency,
+            };
+        }
+        else {
+            return {
+                currencyIn: quoteCurrency,
+                currencyOut: amount.currency,
+            };
+        }
+    }
+    async getGasPriceWei() {
+        // Track how long it takes to resolve this async call.
+        const beforeGasTimestamp = Date.now();
+        // Get an estimate of the gas price to use when estimating gas cost of different routes.
+        const { gasPriceWei } = await this.gasPriceProvider.getGasPrice();
+        metric.putMetric('GasPriceLoad', Date.now() - beforeGasTimestamp, MetricLoggerUnit.Milliseconds);
+        return gasPriceWei;
+    }
+    async getGasModels(gasPriceWei, amountToken, quoteToken, providerConfig) {
+        const beforeGasModel = Date.now();
+        const usdPoolPromise = getHighestLiquidityV3USDPool(this.chainId, this.v3PoolProvider, providerConfig);
+        const nativeCurrency = WRAPPED_NATIVE_CURRENCY[this.chainId];
+        const nativeQuoteTokenV3PoolPromise = !quoteToken.equals(nativeCurrency)
+            ? getHighestLiquidityV3NativePool(quoteToken, this.v3PoolProvider, providerConfig)
+            : Promise.resolve(null);
+        const nativeAmountTokenV3PoolPromise = !amountToken.equals(nativeCurrency)
+            ? getHighestLiquidityV3NativePool(amountToken, this.v3PoolProvider, providerConfig)
+            : Promise.resolve(null);
+        const [usdPool, nativeQuoteTokenV3Pool, nativeAmountTokenV3Pool] = await Promise.all([
+            usdPoolPromise,
+            nativeQuoteTokenV3PoolPromise,
+            nativeAmountTokenV3PoolPromise,
+        ]);
+        const pools = {
+            usdPool: usdPool,
+            nativeQuoteTokenV3Pool: nativeQuoteTokenV3Pool,
+            nativeAmountTokenV3Pool: nativeAmountTokenV3Pool,
+        };
+        const v3GasModelPromise = this.v3GasModelFactory.buildGasModel({
+            chainId: this.chainId,
+            gasPriceWei,
+            pools,
+            amountToken,
+            quoteToken,
+            v2poolProvider: this.v2PoolProvider,
+            l2GasDataProvider: this.l2GasDataProvider,
+            providerConfig: providerConfig,
+        });
+        const mixedRouteGasModelPromise = this.mixedRouteGasModelFactory.buildGasModel({
+            chainId: this.chainId,
+            gasPriceWei,
+            pools,
+            amountToken,
+            quoteToken,
+            v2poolProvider: this.v2PoolProvider,
+            providerConfig: providerConfig,
+        });
+        const [v3GasModel, mixedRouteGasModel] = await Promise.all([
+            v3GasModelPromise,
+            mixedRouteGasModelPromise,
+        ]);
+        metric.putMetric('GasModelCreation', Date.now() - beforeGasModel, MetricLoggerUnit.Milliseconds);
+        return [v3GasModel, mixedRouteGasModel];
+    }
+    // Note multiplications here can result in a loss of precision in the amounts (e.g. taking 50% of 101)
+    // This is reconcilled at the end of the algorithm by adding any lost precision to one of
+    // the splits in the route.
+    getAmountDistribution(amount, routingConfig) {
+        const { distributionPercent } = routingConfig;
+        const percents = [];
+        const amounts = [];
+        for (let i = 1; i <= 100 / distributionPercent; i++) {
+            percents.push(i * distributionPercent);
+            amounts.push(amount.multiply(new Fraction(i * distributionPercent, 100)));
+        }
+        return [percents, amounts];
+    }
+    async buildSwapAndAddMethodParameters(trade, swapAndAddOptions, swapAndAddParameters) {
+        const { swapOptions: { recipient, slippageTolerance, deadline, inputTokenPermit }, addLiquidityOptions: addLiquidityConfig, } = swapAndAddOptions;
+        const preLiquidityPosition = swapAndAddParameters.preLiquidityPosition;
+        const finalBalanceTokenIn = swapAndAddParameters.initialBalanceTokenIn.subtract(trade.inputAmount);
+        const finalBalanceTokenOut = swapAndAddParameters.initialBalanceTokenOut.add(trade.outputAmount);
+        const approvalTypes = await this.swapRouterProvider.getApprovalType(finalBalanceTokenIn, finalBalanceTokenOut);
+        const zeroForOne = finalBalanceTokenIn.currency.wrapped.sortsBefore(finalBalanceTokenOut.currency.wrapped);
+        return {
+            ...SwapRouter.swapAndAddCallParameters(trade, {
+                recipient,
+                slippageTolerance,
+                deadlineOrPreviousBlockhash: deadline,
+                inputTokenPermit,
+            }, Position.fromAmounts({
+                pool: preLiquidityPosition.pool,
+                tickLower: preLiquidityPosition.tickLower,
+                tickUpper: preLiquidityPosition.tickUpper,
+                amount0: zeroForOne
+                    ? finalBalanceTokenIn.quotient.toString()
+                    : finalBalanceTokenOut.quotient.toString(),
+                amount1: zeroForOne
+                    ? finalBalanceTokenOut.quotient.toString()
+                    : finalBalanceTokenIn.quotient.toString(),
+                useFullPrecision: false,
+            }), addLiquidityConfig, approvalTypes.approvalTokenIn, approvalTypes.approvalTokenOut),
+            to: SWAP_ROUTER_02_ADDRESSES(this.chainId),
+        };
+    }
+    emitPoolSelectionMetrics(swapRouteRaw, allPoolsBySelection) {
+        const poolAddressesUsed = new Set();
+        const { routes: routeAmounts } = swapRouteRaw;
+        _(routeAmounts)
+            .flatMap((routeAmount) => {
+            const { poolAddresses } = routeAmount;
+            return poolAddresses;
+        })
+            .forEach((address) => {
+            poolAddressesUsed.add(address.toLowerCase());
+        });
+        for (const poolsBySelection of allPoolsBySelection) {
+            const { protocol } = poolsBySelection;
+            _.forIn(poolsBySelection.selections, (pools, topNSelection) => {
+                const topNUsed = _.findLastIndex(pools, (pool) => poolAddressesUsed.has(pool.id.toLowerCase())) + 1;
+                metric.putMetric(_.capitalize(`${protocol}${topNSelection}`), topNUsed, MetricLoggerUnit.Count);
+            });
+        }
+        let hasV3Route = false;
+        let hasV2Route = false;
+        let hasMixedRoute = false;
+        for (const routeAmount of routeAmounts) {
+            if (routeAmount.protocol === Protocol.V3) {
+                hasV3Route = true;
+            }
+            if (routeAmount.protocol === Protocol.V2) {
+                hasV2Route = true;
+            }
+            if (routeAmount.protocol === Protocol.MIXED) {
+                hasMixedRoute = true;
+            }
+        }
+        if (hasMixedRoute && (hasV3Route || hasV2Route)) {
+            if (hasV3Route && hasV2Route) {
+                metric.putMetric(`MixedAndV3AndV2SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedAndV3AndV2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else if (hasV3Route) {
+                metric.putMetric(`MixedAndV3SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedAndV3SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else if (hasV2Route) {
+                metric.putMetric(`MixedAndV2SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedAndV2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV3Route && hasV2Route) {
+            metric.putMetric(`V3AndV2SplitRoute`, 1, MetricLoggerUnit.Count);
+            metric.putMetric(`V3AndV2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+        }
+        else if (hasMixedRoute) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`MixedSplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedSplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`MixedRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`MixedRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV3Route) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`V3SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V3SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`V3Route`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V3RouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+        else if (hasV2Route) {
+            if (routeAmounts.length > 1) {
+                metric.putMetric(`V2SplitRoute`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V2SplitRouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+            else {
+                metric.putMetric(`V2Route`, 1, MetricLoggerUnit.Count);
+                metric.putMetric(`V2RouteForChain${this.chainId}`, 1, MetricLoggerUnit.Count);
+            }
+        }
+    }
+    calculateOptimalRatio(position, sqrtRatioX96, zeroForOne) {
+        const upperSqrtRatioX96 = TickMath.getSqrtRatioAtTick(position.tickUpper);
+        const lowerSqrtRatioX96 = TickMath.getSqrtRatioAtTick(position.tickLower);
+        // returns Fraction(0, 1) for any out of range position regardless of zeroForOne. Implication: function
+        // cannot be used to determine the trading direction of out of range positions.
+        if (JSBI.greaterThan(sqrtRatioX96, upperSqrtRatioX96) ||
+            JSBI.lessThan(sqrtRatioX96, lowerSqrtRatioX96)) {
+            return new Fraction(0, 1);
+        }
+        const precision = JSBI.BigInt('1' + '0'.repeat(18));
+        let optimalRatio = new Fraction(SqrtPriceMath.getAmount0Delta(sqrtRatioX96, upperSqrtRatioX96, precision, true), SqrtPriceMath.getAmount1Delta(sqrtRatioX96, lowerSqrtRatioX96, precision, true));
+        if (!zeroForOne)
+            optimalRatio = optimalRatio.invert();
+        return optimalRatio;
+    }
+    async userHasSufficientBalance(fromAddress, tradeType, amount, quote) {
+        try {
+            const neededBalance = tradeType === TradeType.EXACT_INPUT ? amount : quote;
+            let balance;
+            if (neededBalance.currency.isNative) {
+                balance = await this.provider.getBalance(fromAddress);
+            }
+            else {
+                const tokenContract = Erc20__factory.connect(neededBalance.currency.address, this.provider);
+                balance = await tokenContract.balanceOf(fromAddress);
+            }
+            return balance.gte(BigNumber.from(neededBalance.quotient.toString()));
+        }
+        catch (e) {
+            log.error(e, 'Error while checking user balance');
+            return false;
+        }
+    }
+    absoluteValue(fraction) {
+        const numeratorAbs = JSBI.lessThan(fraction.numerator, JSBI.BigInt(0))
+            ? JSBI.unaryMinus(fraction.numerator)
+            : fraction.numerator;
+        const denominatorAbs = JSBI.lessThan(fraction.denominator, JSBI.BigInt(0))
+            ? JSBI.unaryMinus(fraction.denominator)
+            : fraction.denominator;
+        return new Fraction(numeratorAbs, denominatorAbs);
+    }
+    getBlockNumberPromise() {
+        return retry(async (_b, attempt) => {
+            if (attempt > 1) {
+                log.info(`Get block number attempt ${attempt}`);
+            }
+            return this.provider.getBlockNumber();
+        }, {
+            retries: 2,
+            minTimeout: 100,
+            maxTimeout: 1000,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alpha-router.js","sourceRoot":"","sources":["../../../../src/routers/alpha-router/alpha-router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAgB,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,kBAAkB,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAS,MAAM,qBAAqB,CAAC;AAElE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EACL,OAAO,EAEP,QAAQ,EAER,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,MAAM,aAAa,CAAC;AAChC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,CAAC,MAAM,QAAQ,CAAC;AACvB,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,OAAO,EACL,YAAY,EACZ,SAAS,EACT,yBAAyB,EACzB,gCAAgC,EAChC,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EAMzB,sBAAsB,EACtB,WAAW,EACX,uBAAuB,EACvB,oBAAoB,EAEpB,wBAAwB,EACxB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,eAAe,EACf,+BAA+B,EAC/B,+BAA+B,GAChC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,wBAAwB,GAEzB,MAAM,6CAA6C,CAAC;AAMrD,OAAO,EAAkB,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAEL,sBAAsB,GACvB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAEL,cAAc,GACf,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAEL,uBAAuB,EAGvB,uBAAuB,GACxB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAEL,cAAc,GACf,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAC5E,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,cAAc,EACd,kBAAkB,EAElB,YAAY,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,+BAA+B,EAC/B,4BAA4B,GAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,EACL,yBAAyB,EACzB,UAAU,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAWL,iBAAiB,GAElB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,UAAU,CAAC;AAMlB,OAAO,EAAiB,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAW/E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yDAAyD,CAAC;AAC7G,OAAO,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,EAAmB,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAwG7E,MAAM,OAAO,mBAAuB,SAAQ,GAAc;IAC/C,GAAG,CAAC,GAAW,EAAE,KAAQ;QAChC,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;CACF;AA8GD,MAAM,OAAO,WAAW;IA+BtB,YAAY,EACV,OAAO,EACP,QAAQ,EACR,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,aAAa,EACb,wBAAwB,EACxB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,EACzB,kBAAkB,EAClB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,SAAS,EACT,oBAAoB,GACF;QAClB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,kBAAkB;YACrB,kBAAkB,aAAlB,kBAAkB,cAAlB,kBAAkB,GAClB,IAAI,wBAAwB,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAO,CAAC,CAAC;QAC3D,IAAI,CAAC,cAAc;YACjB,cAAc,aAAd,cAAc,cAAd,cAAc,GACd,IAAI,qBAAqB,CACvB,IAAI,CAAC,OAAO,EACZ,IAAI,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,EACpE,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAClE,CAAC;QACJ,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;QAEjD,IAAI,oBAAoB,EAAE;YACxB,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;SAClD;aAAM;YACL,QAAQ,OAAO,EAAE;gBACf,KAAK,OAAO,CAAC,QAAQ,CAAC;gBACtB,KAAK,OAAO,CAAC,eAAe,CAAC;gBAC7B,KAAK,OAAO,CAAC,IAAI,CAAC;gBAClB,KAAK,OAAO,CAAC,WAAW;oBACtB,IAAI,CAAC,oBAAoB,GAAG,IAAI,oBAAoB,CAClD,OAAO,EACP,QAAQ,EACR,IAAI,CAAC,kBAAkB,EACvB;wBACE,OAAO,EAAE,CAAC;wBACV,UAAU,EAAE,GAAG;wBACf,UAAU,EAAE,IAAI;qBACjB,EACD;wBACE,cAAc,EAAE,GAAG;wBACnB,eAAe,EAAE,OAAS;wBAC1B,mBAAmB,EAAE,GAAG;qBACzB,EACD;wBACE,gBAAgB,EAAE,OAAS;wBAC3B,cAAc,EAAE,EAAE;qBACnB,EACD;wBACE,gBAAgB,EAAE,OAAS;wBAC3B,cAAc,EAAE,EAAE;qBACnB,EACD;wBACE,eAAe,EAAE,CAAC,EAAE;wBACpB,QAAQ,EAAE;4BACR,OAAO,EAAE,IAAI;4BACb,sBAAsB,EAAE,CAAC;4BACzB,mBAAmB,EAAE,CAAC,EAAE;yBACzB;qBACF,CACF,CAAC;oBACF,MAAM;gBACR,KAAK,OAAO,CAAC,YAAY,CAAC;gBAC1B,KAAK,OAAO,CAAC,eAAe;oBAC1B,IAAI,CAAC,oBAAoB,GAAG,IAAI,oBAAoB,CAClD,OAAO,EACP,QAAQ,EACR,IAAI,CAAC,kBAAkB,EACvB;wBACE,OAAO,EAAE,CAAC;wBACV,UAAU,EAAE,GAAG;wBACf,UAAU,EAAE,IAAI;qBACjB,EACD;wBACE,cAAc,EAAE,EAAE;wBAClB,eAAe,EAAE,QAAU;wBAC3B,mBAAmB,EAAE,GAAG;qBACzB,EACD;wBACE,gBAAgB,EAAE,QAAU;wBAC5B,cAAc,EAAE,CAAC;qBAClB,EACD;wBACE,gBAAgB,EAAE,QAAU;wBAC5B,cAAc,EAAE,CAAC;qBAClB,CACF,CAAC;oBACF,MAAM;gBACR,KAAK,OAAO,CAAC,IAAI,CAAC;gBAClB,KAAK,OAAO,CAAC,cAAc;oBACzB,IAAI,CAAC,oBAAoB,GAAG,IAAI,oBAAoB,CAClD,OAAO,EACP,QAAQ,EACR,IAAI,CAAC,kBAAkB,EACvB;wBACE,OAAO,EAAE,CAAC;wBACV,UAAU,EAAE,GAAG;wBACf,UAAU,EAAE,IAAI;qBACjB,EACD;wBACE,cAAc,EAAE,EAAE;wBAClB,eAAe,EAAE,OAAS;wBAC1B,mBAAmB,EAAE,GAAG;qBACzB,EACD;wBACE,gBAAgB,EAAE,OAAS;wBAC3B,cAAc,EAAE,CAAC;qBAClB,EACD;wBACE,gBAAgB,EAAE,OAAS;wBAC3B,cAAc,EAAE,CAAC;qBAClB,CACF,CAAC;oBACF,MAAM;gBACR;oBACE,IAAI,CAAC,oBAAoB,GAAG,IAAI,oBAAoB,CAClD,OAAO,EACP,QAAQ,EACR,IAAI,CAAC,kBAAkB,EACvB;wBACE,OAAO,EAAE,CAAC;wBACV,UAAU,EAAE,GAAG;wBACf,UAAU,EAAE,IAAI;qBACjB,EACD;wBACE,cAAc,EAAE,GAAG;wBACnB,eAAe,EAAE,MAAO;wBACxB,mBAAmB,EAAE,IAAI;qBAC1B,EACD;wBACE,gBAAgB,EAAE,OAAS;wBAC3B,cAAc,EAAE,EAAE;qBACnB,CACF,CAAC;oBACF,MAAM;aACT;SACF;QAED,IAAI,CAAC,cAAc;YACjB,cAAc,aAAd,cAAc,cAAd,cAAc,GACd,IAAI,qBAAqB,CACvB,OAAO,EACP,IAAI,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,EACpD,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CACjE,CAAC;QAEJ,IAAI,CAAC,eAAe,GAAG,eAAe,aAAf,eAAe,cAAf,eAAe,GAAI,IAAI,eAAe,EAAE,CAAC;QAEhE,IAAI,CAAC,wBAAwB;YAC3B,wBAAwB,aAAxB,wBAAwB,cAAxB,wBAAwB,GACxB,IAAI,wBAAwB,CAC1B,OAAO,EACP,kBAA+B,EAC/B,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CACnE,CAAC;QACJ,IAAI,CAAC,aAAa;YAChB,aAAa,aAAb,aAAa,cAAb,aAAa,GACb,IAAI,gCAAgC,CAClC,OAAO,EACP,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,EAClE,IAAI,wBAAwB,CAC1B,OAAO,EACP,kBAAkB,EAClB,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CACnE,EACD,IAAI,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,CACpD,CAAC;QAEJ,MAAM,SAAS,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAE9C,gIAAgI;QAChI,IAAI,kBAAkB,EAAE;YACtB,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;SAC9C;aAAM;YACL,IAAI,CAAC,kBAAkB,GAAG,IAAI,+BAA+B,CAAC;gBAC5D,IAAI,yBAAyB,CAC3B,OAAO,EACP,IAAI,mBAAmB,CACrB,OAAO,EACP,gEAAgE,SAAS,OAAO,EAChF,SAAS,EACT,CAAC,CACF,EACD,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAClE;gBACD,IAAI,wBAAwB,CAAC,OAAO,CAAC;aACtC,CAAC,CAAC;SACJ;QAED,IAAI,kBAAkB,EAAE;YACtB,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;SAC9C;aAAM;YACL,IAAI,CAAC,kBAAkB,GAAG,IAAI,+BAA+B,CAAC;gBAC5D,IAAI,yBAAyB,CAC3B,OAAO,EACP,IAAI,mBAAmB,CACrB,OAAO,EACP,gEAAgE,SAAS,OAAO,EAChF,SAAS,EACT,CAAC,CACF,EACD,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAClE;gBACD,IAAI,wBAAwB,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC;aAC3D,CAAC,CAAC;SACJ;QAED,IAAI,wBAA2C,CAAC;QAChD,IAAI,eAAe,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;YAC7C,wBAAwB,GAAG,IAAI,uBAAuB,CACpD,OAAO,EACP,IAAI,uBAAuB,CAAC,IAAI,CAAC,QAA2B,CAAC,EAC7D,IAAI,sBAAsB,CAAC,IAAI,CAAC,QAA2B,CAAC,CAC7D,CAAC;SACH;aAAM;YACL,wBAAwB,GAAG,IAAI,yBAAyB,CACtD,uBAAuB,CACxB,CAAC;SACH;QAED,IAAI,CAAC,gBAAgB;YACnB,gBAAgB,aAAhB,gBAAgB,cAAhB,gBAAgB,GAChB,IAAI,yBAAyB,CAC3B,OAAO,EACP,wBAAwB,EACxB,IAAI,WAAW,CACb,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAC/C,CACF,CAAC;QACJ,IAAI,CAAC,iBAAiB;YACpB,iBAAiB,aAAjB,iBAAiB,cAAjB,iBAAiB,GAAI,IAAI,0BAA0B,EAAE,CAAC;QACxD,IAAI,CAAC,iBAAiB;YACpB,iBAAiB,aAAjB,iBAAiB,cAAjB,iBAAiB,GAAI,IAAI,0BAA0B,EAAE,CAAC;QACxD,IAAI,CAAC,yBAAyB;YAC5B,yBAAyB,aAAzB,yBAAyB,cAAzB,yBAAyB,GAAI,IAAI,kCAAkC,EAAE,CAAC;QAExE,IAAI,CAAC,kBAAkB;YACrB,kBAAkB,aAAlB,kBAAkB,cAAlB,kBAAkB,GAClB,IAAI,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAEhE,IAAI,OAAO,KAAK,OAAO,CAAC,QAAQ,IAAI,OAAO,KAAK,OAAO,CAAC,IAAI,EAAE;YAC5D,IAAI,CAAC,iBAAiB;gBACpB,uBAAuB,aAAvB,uBAAuB,cAAvB,uBAAuB,GACvB,IAAI,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;SACjE;QACD,IACE,OAAO,KAAK,OAAO,CAAC,YAAY;YAChC,OAAO,KAAK,OAAO,CAAC,eAAe,EACnC;YACA,IAAI,CAAC,iBAAiB;gBACpB,uBAAuB,aAAvB,uBAAuB,cAAvB,uBAAuB,GACvB,IAAI,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;SACvD;QACD,IAAI,sBAAsB,EAAE;YAC1B,IAAI,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;SACtD;aAAM,IAAI,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,OAAO,EAAE;YAC3C,IAAI,CAAC,sBAAsB,GAAG,IAAI,sBAAsB,CACtD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,kBAAkB,EACvB,IAAI,WAAW,CAAC,IAAI,SAAS,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CACpE,CAAC;SACH;QAED,0BAA0B;QAC1B,6FAA6F;QAC7F,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,wBAAwB,EAC7B,IAAI,CAAC,sBAAsB,CAC5B,CAAC;QAEF,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,oBAAoB,EACzB,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,wBAAwB,EAC7B,IAAI,CAAC,sBAAsB,CAC5B,CAAC;QAEF,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAChC,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,kBAAkB,EACvB,IAAI,CAAC,cAAc,EACnB,IAAI,CAAC,oBAAoB,EACzB,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,wBAAwB,EAC7B,IAAI,CAAC,sBAAsB,CAC5B,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,YAAY,CACvB,aAA6B,EAC7B,aAA6B,EAC7B,QAAkB,EAClB,gBAAkC,EAClC,iBAAqC,EACrC,gBAA4C,+BAA+B,CACzE,IAAI,CAAC,OAAO,CACb;QAED,IACE,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,EAC1E;YACA,CAAC,aAAa,EAAE,aAAa,CAAC,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;SACjE;QAED,IAAI,mBAAmB,GAAG,IAAI,CAAC,qBAAqB,CAClD,QAAQ,EACR,QAAQ,CAAC,IAAI,CAAC,YAAY,EAC1B,IAAI,CACL,CAAC;QACF,6DAA6D;QAC7D,IAAI,UAAmB,CAAC;QACxB,IAAI,QAAQ,CAAC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,SAAS,EAAE;YAClD,UAAU,GAAG,IAAI,CAAC;SACnB;aAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,SAAS,EAAE;YACzD,UAAU,GAAG,KAAK,CAAC;SACpB;aAAM;YACL,UAAU,GAAG,IAAI,QAAQ,CACvB,aAAa,CAAC,QAAQ,EACtB,aAAa,CAAC,QAAQ,CACvB,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC;YACnC,IAAI,CAAC,UAAU;gBAAE,mBAAmB,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC;SACrE;QAED,MAAM,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,UAAU;YAC9C,CAAC,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC;YAChC,CAAC,CAAC,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QAEnC,IAAI,YAAY,GAAG,mBAAmB,CAAC;QACvC,IAAI,kBAAkB,GAAG,QAAQ,CAAC,IAAI,CAAC;QACvC,IAAI,YAAY,GAAa,UAAU;YACrC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW;YAC3B,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC;QAC9B,IAAI,IAAI,GAAqB,IAAI,CAAC;QAClC,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,sEAAsE;QACtE,OAAO,CAAC,aAAa,EAAE;YACrB,CAAC,EAAE,CAAC;YACJ,IAAI,CAAC,GAAG,gBAAgB,CAAC,aAAa,EAAE;gBACtC,GAAG,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;gBACpC,OAAO;oBACL,MAAM,EAAE,iBAAiB,CAAC,cAAc;oBACxC,KAAK,EAAE,yBAAyB;iBACjC,CAAC;aACH;YAED,MAAM,YAAY,GAAG,sBAAsB,CACzC,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,aAAa,CACd,CAAC;YACF,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC3B,GAAG,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;gBAC7C,OAAO;oBACL,MAAM,EAAE,iBAAiB,CAAC,cAAc;iBACzC,CAAC;aACH;YACD,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CACrB,YAAY,EACZ,aAAa,CAAC,QAAQ,EACtB,SAAS,CAAC,WAAW,EACrB,SAAS,EACT;gBACE,GAAG,+BAA+B,CAAC,IAAI,CAAC,OAAO,CAAC;gBAChD,GAAG,aAAa;gBAChB,2FAA2F;gBAC3F,yEAAyE;gBACzE,SAAS,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,iBAAiB,CAAC;aAC3C,CACF,CAAC;YACF,IAAI,CAAC,IAAI,EAAE;gBACT,GAAG,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;gBAC7C,OAAO;oBACL,MAAM,EAAE,iBAAiB,CAAC,cAAc;oBACxC,KAAK,EAAE,gBAAgB;iBACxB,CAAC;aACH;YAED,MAAM,mBAAmB,GAAG,YAAY,CAAC,QAAQ,CAC/C,IAAI,CAAC,KAAM,CAAC,WAAW,CACxB,CAAC;YACF,MAAM,oBAAoB,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,KAAM,CAAC,YAAY,CAAC,CAAC;YACzE,MAAM,QAAQ,GAAG,mBAAmB,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;YAElE,IAAI,qBAAqB,CAAC;YAC1B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC3B,IAAI,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,EAAE;oBAClC,MAAM,OAAO,GAAG,KAA8B,CAAC;oBAC/C,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;wBACtC,IACE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;4BACxC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;4BACxC,IAAI,CAAC,GAAG,KAAK,QAAQ,CAAC,IAAI,CAAC,GAAG,EAC9B;4BACA,qBAAqB,GAAG,IAAI,CAAC,MAAM,CACjC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAE,CAAC,QAAQ,EAAE,CAC7C,CAAC;4BACF,YAAY,GAAG,IAAI,CAAC,qBAAqB,CACvC,QAAQ,EACR,IAAI,CAAC,MAAM,CAAC,qBAAsB,CAAC,QAAQ,EAAE,CAAC,EAC9C,UAAU,CACX,CAAC;yBACH;oBACH,CAAC,CAAC,CAAC;iBACJ;YACH,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,qBAAqB,EAAE;gBAC1B,YAAY,GAAG,mBAAmB,CAAC;aACpC;YACD,aAAa;gBACX,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC;oBAC9B,IAAI,CAAC,aAAa,CAChB,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CACrD,CAAC,QAAQ,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC;YAEnD,IAAI,aAAa,IAAI,qBAAqB,EAAE;gBAC1C,kBAAkB,GAAG,IAAI,IAAI,CAC3B,QAAQ,CAAC,IAAI,CAAC,MAAM,EACpB,QAAQ,CAAC,IAAI,CAAC,MAAM,EACpB,QAAQ,CAAC,IAAI,CAAC,GAAG,EACjB,qBAAqB,EACrB,QAAQ,CAAC,IAAI,CAAC,SAAS,EACvB,QAAQ,CAAC,kBAAkB,CAAC,qBAAqB,CAAC,EAClD,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAC/B,CAAC;aACH;YACD,YAAY,GAAG,IAAI,CAAC,KAAM,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAM,CAAC,WAAW,CAAC,CAAC;YAExE,GAAG,CAAC,IAAI,CACN;gBACE,YAAY,EAAE,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBACjD,YAAY,EAAE,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBACjD,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBACzC,mBAAmB,EAAE,mBAAmB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC/D,oBAAoB,EAAE,oBAAoB,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;gBACjE,mBAAmB,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC;gBACrE,UAAU,EAAE,CAAC,CAAC,QAAQ,EAAE;aACzB,EACD,mCAAmC,CACpC,CAAC;YAEF,IAAI,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC3B,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;gBAC9B,OAAO;oBACL,MAAM,EAAE,iBAAiB,CAAC,cAAc;oBACxC,KAAK,EAAE,iDAAiD;iBACzD,CAAC;aACH;SACF;QAED,IAAI,CAAC,IAAI,EAAE;YACT,OAAO;gBACL,MAAM,EAAE,iBAAiB,CAAC,cAAc;gBACxC,KAAK,EAAE,gBAAgB;aACxB,CAAC;SACH;QACD,IAAI,gBAA8C,CAAC;QACnD,IAAI,iBAAiB,EAAE;YACrB,gBAAgB,GAAG,MAAM,IAAI,CAAC,+BAA+B,CAC3D,IAAI,CAAC,KAAK,EACV,iBAAiB,EACjB;gBACE,qBAAqB,EAAE,YAAY;gBACnC,sBAAsB,EAAE,aAAa;gBACrC,oBAAoB,EAAE,QAAQ;aAC/B,CACF,CAAC;SACH;QAED,OAAO;YACL,MAAM,EAAE,iBAAiB,CAAC,OAAO;YACjC,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,kBAAkB,EAAE;SACxE,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,KAAK,CAChB,MAAsB,EACtB,aAAuB,EACvB,SAAoB,EACpB,UAAwB,EACxB,uBAAmD,EAAE;;QAErD,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,GAC/B,IAAI,CAAC,mCAAmC,CACtC,SAAS,EACT,MAAM,EACN,aAAa,CACd,CAAC;QAEJ,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QACnC,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC;QAErC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5C,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/C,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;QACjD,MAAM,CAAC,WAAW,CAChB,WAAW,EACX,SAAS,KAAK,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAC7D,CAAC;QAEF,MAAM,CAAC,SAAS,CACd,yBAAyB,IAAI,CAAC,OAAO,EAAE,EACvC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;QAEF,sFAAsF;QACtF,uBAAuB;QACvB,MAAM,WAAW,GACf,MAAA,oBAAoB,CAAC,WAAW,mCAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAEnE,MAAM,aAAa,GAAsB,CAAC,CAAC,KAAK,CAC9C,EAAE,EACF,+BAA+B,CAAC,IAAI,CAAC,OAAO,CAAC,EAC7C,oBAAoB,EACpB,EAAE,WAAW,EAAE,CAChB,CAAC;QAEF,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;QAEhD,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC;QAEzC,MAAM,CAAC,UAAU,EAAE,kBAAkB,CAAC,GAAG,MAAM,IAAI,CAAC,YAAY,CAC9D,WAAW,EACX,MAAM,CAAC,QAAQ,CAAC,OAAO,EACvB,UAAU,EACV,EAAE,WAAW,EAAE,CAChB,CAAC;QAEF,yFAAyF;QACzF,oDAAoD;QACpD,MAAM,SAAS,GAAe,KAAK,CAAC,IAAI,CACtC,IAAI,GAAG,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAC1C,CAAC;QAEF,MAAM,SAAS,GAAG,MAAM,CAAA,MAAA,IAAI,CAAC,oBAAoB,0CAAE,YAAY,CAC7D,IAAI,CAAC,OAAO,EACZ,MAAM,EACN,UAAU,EACV,SAAS,EACT,SAAS,CACV,CAAA,CAAC;QAEF,qBAAqB;QACrB,IAAI,YAAsC,CAAC;QAC3C,IAAI,SAAS,KAAK,SAAS,CAAC,QAAQ,EAAE;YACpC,YAAY,GAAG,MAAM,CAAA,MAAA,IAAI,CAAC,oBAAoB,0CAAE,cAAc,CAC5D,IAAI,CAAC,OAAO,EACZ,MAAM,EACN,UAAU,EACV,SAAS,EACT,SAAS,EACT,MAAM,WAAW,CAClB,CAAA,CAAC;SACH;QAED,IAAI,SAAS,IAAI,SAAS,KAAK,SAAS,CAAC,QAAQ,IAAI,CAAC,YAAY,EAAE;YAClE,MAAM,CAAC,SAAS,CACd,uBAAuB,SAAS,EAAE,EAClC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;YACF,GAAG,CAAC,IAAI,CACN;gBACE,OAAO,EAAE,OAAO,CAAC,MAAM;gBACvB,cAAc,EAAE,OAAO,CAAC,OAAO;gBAC/B,QAAQ,EAAE,QAAQ,CAAC,MAAM;gBACzB,eAAe,EAAE,QAAQ,CAAC,OAAO;gBACjC,SAAS;gBACT,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE;gBACxB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;aACxC,EACD,uBAAuB,SAAS,QAAQ,IAAI,CAAC,+BAA+B,CAC1E,OAAO,EACP,QAAQ,EACR,SAAS,CACV,EAAE,CACJ,CAAC;SACH;aAAM,IAAI,YAAY,EAAE;YACvB,MAAM,CAAC,SAAS,CACd,sBAAsB,SAAS,EAAE,EACjC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;YACF,GAAG,CAAC,IAAI,CACN;gBACE,OAAO,EAAE,OAAO,CAAC,MAAM;gBACvB,cAAc,EAAE,OAAO,CAAC,OAAO;gBAC/B,QAAQ,EAAE,QAAQ,CAAC,MAAM;gBACzB,eAAe,EAAE,QAAQ,CAAC,OAAO;gBACjC,SAAS;gBACT,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE;gBACxB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;aACxC,EACD,sBAAsB,SAAS,QAAQ,IAAI,CAAC,+BAA+B,CACzE,OAAO,EACP,QAAQ,EACR,SAAS,CACV,EAAE,CACJ,CAAC;SACH;QAED,IAAI,yBAAyB,GAC3B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,YAAY,EAAE;YAChB,yBAAyB,GAAG,IAAI,CAAC,qBAAqB,CACpD,YAAY,EACZ,MAAM,WAAW,EACjB,MAAM,EACN,UAAU,EACV,SAAS,EACT,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,WAAW,CACZ,CAAC;SACH;QAED,IAAI,yBAAyB,GAC3B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,YAAY,IAAI,SAAS,KAAK,SAAS,CAAC,QAAQ,EAAE;YACrD,yBAAyB,GAAG,IAAI,CAAC,qBAAqB,CACpD,MAAM,EACN,OAAO,EACP,QAAQ,EACR,SAAS,EACT,UAAU,EACV,SAAS,EACT,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,WAAW,CACZ,CAAC;SACH;QAED,MAAM,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACjE,yBAAyB;YACzB,yBAAyB;SAC1B,CAAC,CAAC;QAEH,IAAI,YAAkC,CAAC;QACvC,IAAI,SAAS,KAAK,SAAS,CAAC,QAAQ,IAAI,kBAAkB,EAAE;YAC1D,GAAG,CAAC,IAAI,CACN,gBAAgB,SAAS,yCAAyC,CACnE,CAAC;YACF,YAAY,GAAG,kBAAkB,CAAC;SACnC;aAAM;YACL,GAAG,CAAC,IAAI,CACN,gBAAgB,SAAS,2CAA2C,CACrE,CAAC;YACF,YAAY,GAAG,kBAAkB,CAAC;SACnC;QAED,IACE,SAAS,KAAK,SAAS,CAAC,UAAU;YAClC,kBAAkB;YAClB,kBAAkB,EAClB;YACA,MAAM,SAAS,GAAG,kBAAkB,CAAC,KAAK,CAAC,QAAQ,CACjD,kBAAkB,CAAC,KAAK,CACzB,CAAC;YACF,MAAM,oBAAoB,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,QAAQ,CACvE,kBAAkB,CAAC,gBAAgB,CACpC,CAAC;YACF,MAAM,WAAW,GAAG,kBAAkB,CAAC,gBAAgB,CAAC,GAAG,CACzD,kBAAkB,CAAC,gBAAgB,CACpC,CAAC;YAEF,kHAAkH;YAClH,IACE,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;gBACrB,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EACvD;gBACA,kGAAkG;gBAClG,MAAM,eAAe,GAAG,oBAAoB;qBACzC,MAAM,CAAC,kBAAkB,CAAC,gBAAgB,CAAC;qBAC3C,QAAQ,CAAC,GAAG,CAAC,CAAC;gBAEjB,MAAM,CAAC,SAAS,CACd,mDAAmD,EACnD,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,EACjC,gBAAgB,CAAC,OAAO,CACzB,CAAC;gBAEF,GAAG,CAAC,IAAI,CACN;oBACE,cAAc,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE;oBAClD,cAAc,EAAE,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE;oBAClD,SAAS,EAAE,SAAS,CAAC,OAAO,EAAE;oBAC9B,yBAAyB,EACvB,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,EAAE;oBAC/C,yBAAyB,EACvB,kBAAkB,CAAC,gBAAgB,CAAC,OAAO,EAAE;oBAC/C,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,EAAE;oBACpD,gBAAgB,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,QAAQ,EAAE;oBAChE,gBAAgB,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,QAAQ,EAAE;oBAChE,WAAW,EAAE,WAAW,CAAC,QAAQ,EAAE;oBACnC,eAAe,EAAE,kBAAkB,CAAC,MAAM,CAAC,QAAQ,EAAE;oBACrD,eAAe,EAAE,kBAAkB,CAAC,MAAM,CAAC,QAAQ,EAAE;oBACrD,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE;oBACxB,cAAc,EAAE,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,cAAc;oBAC5C,IAAI,EAAE,IAAI,CAAC,+BAA+B,CACxC,OAAO,EACP,QAAQ,EACR,SAAS,CACV;oBACD,WAAW;iBACZ,EACD,gDAAgD,IAAI,CAAC,+BAA+B,CAClF,OAAO,EACP,QAAQ,EACR,SAAS,CACV,EAAE,CACJ,CAAC;aACH;SACF;QAED,IAAI,CAAC,YAAY,EAAE;YACjB,OAAO,IAAI,CAAC;SACb;QAED,MAAM,EACJ,KAAK,EACL,gBAAgB,EAChB,gBAAgB,EAChB,MAAM,EAAE,YAAY,EACpB,0BAA0B,EAC1B,mBAAmB,GACpB,GAAG,YAAY,CAAC;QAEjB,IACE,IAAI,CAAC,oBAAoB;YACzB,SAAS,KAAK,SAAS,CAAC,QAAQ;YAChC,kBAAkB,EAClB;YACA,mCAAmC;YACnC,MAAM,aAAa,GAAG,YAAY,CAAC,yBAAyB,CAC1D,kBAAkB,CAAC,MAAM,EACzB,IAAI,CAAC,OAAO,EACZ,OAAO,EACP,QAAQ,EACR,SAAS,CAAC,IAAI,EAAE,EAAE,yDAAyD;YAC3E,MAAM,WAAW,EACjB,SAAS,EACT,MAAM,CAAC,OAAO,EAAE,CACjB,CAAC;YAEF,IAAI,aAAa,EAAE;gBACjB,yEAAyE;gBACzE,uFAAuF;gBACvF,IAAI,CAAC,oBAAoB;qBACtB,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC;qBACrC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;oBAChB,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC;oBAChD,MAAM,CAAC,SAAS,CACd,kBAAkB,MAAM,EAAE,EAC1B,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;gBACJ,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;oBAChB,GAAG,CAAC,KAAK,CACP;wBACE,MAAM,EAAE,MAAM;wBACd,SAAS,EAAE,IAAI,CAAC,+BAA+B,CAC7C,OAAO,EACP,QAAQ,EACR,SAAS,CACV;qBACF,EACD,wBAAwB,CACzB,CAAC;oBAEF,MAAM,CAAC,SAAS,CACd,wBAAwB,EACxB,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;gBACJ,CAAC,CAAC,CAAC;aACN;SACF;QAED,MAAM,CAAC,SAAS,CACd,qBAAqB,IAAI,CAAC,OAAO,EAAE,EACnC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;QAEF,uDAAuD;QACvD,MAAM,KAAK,GAAG,UAAU,CACtB,UAAU,EACV,WAAW,EACX,SAAS,EACT,YAAY,CACb,CAAC;QAEF,IAAI,gBAA8C,CAAC;QAEnD,8FAA8F;QAC9F,8BAA8B;QAC9B,IAAI,UAAU,EAAE;YACd,gBAAgB,GAAG,yBAAyB,CAC1C,KAAK,EACL,UAAU,EACV,IAAI,CAAC,OAAO,CACb,CAAC;SACH;QAED,MAAM,SAAS,GAAc;YAC3B,KAAK;YACL,gBAAgB;YAChB,gBAAgB;YAChB,0BAA0B;YAC1B,mBAAmB;YACnB,WAAW;YACX,KAAK,EAAE,YAAY;YACnB,KAAK;YACL,gBAAgB;YAChB,WAAW,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC;SAC/C,CAAC;QAEF,IACE,UAAU;YACV,UAAU,CAAC,QAAQ;YACnB,gBAAgB;YAChB,gBAAgB,CAAC,QAAQ,EACzB;YACA,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;aAC/C;YACD,GAAG,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,qBAAqB,CAAC,CAAC;YAClE,MAAM,WAAW,GAAG,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC;YACpD,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAClC,MAAM,uBAAuB,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAC3D,WAAW,EACX,UAAU,EACV,SAAS,EACT,MAAM;YACN,qDAAqD;YACrD,8CAA8C;YAC9C,cAAc,CAAC,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,EACtE,IAAI,CAAC,iBAAiB;gBACpB,CAAC,CAAC,MAAM,IAAI,CAAC,iBAAkB,CAAC,UAAU,EAAE;gBAC5C,CAAC,CAAC,SAAS,EACb,EAAE,WAAW,EAAE,CAChB,CAAC;YACF,MAAM,CAAC,SAAS,CACd,qBAAqB,EACrB,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,EAC3B,gBAAgB,CAAC,YAAY,CAC9B,CAAC;YACF,OAAO,uBAAuB,CAAC;SAChC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,YAA0B,EAC1B,WAAmB,EACnB,MAAsB,EACtB,UAAiB,EACjB,SAAoB,EACpB,aAAgC,EAChC,UAA4C,EAC5C,kBAAuD,EACvD,WAAsB;QAEtB,GAAG,CAAC,IAAI,CACN;YACE,SAAS,EAAE,YAAY,CAAC,gBAAgB;YACxC,SAAS,EAAE,YAAY,CAAC,SAAS;YACjC,iBAAiB,EAAE,YAAY,CAAC,WAAW;YAC3C,gBAAgB,EAAE,WAAW;SAC9B,EACD,4BAA4B,CAC7B,CAAC;QACF,MAAM,aAAa,GAA+B,EAAE,CAAC;QAErD,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,MAAM,CACzC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,CAC1C,CAAC;QACF,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,MAAM,CACzC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,CAC1C,CAAC;QACF,MAAM,WAAW,GAAG,YAAY,CAAC,MAAM,CAAC,MAAM,CAC5C,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,KAAK,CAC7C,CAAC;QAEF,IAAI,QAAkB,CAAC;QACvB,IAAI,OAAyB,CAAC;QAC9B,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAClC,2GAA2G;YAC3G,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;SACzE;aAAM,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE;YAC1C,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;SACzC;aAAM;YACL,mEAAmE;YACnE,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SAC9B;QAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACvB,MAAM,iBAAiB,GAAc,QAAQ,CAAC,GAAG,CAC/C,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,KAAgB,CAC9C,CAAC;YAEF,aAAa,CAAC,IAAI,CAChB,IAAI,CAAC,QAAQ,CAAC,SAAS,CACrB,iBAAiB,EACjB,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,UAAU,CACX,CACF,CAAC;SACH;QAED,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACvB,aAAa,CAAC,IAAI;YAChB,4GAA4G;YAC5G,oGAAoG;YACpG,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAC/B,QAAQ,CAAC,CAAC,CAAE,CAAC,OAAO,EACpB,QAAQ,CAAC,CAAC,CAAE,CAAC,QAAQ,EACrB,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,WAAW,CACZ,CACF,CAAC;SACH;QAED,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1B,MAAM,oBAAoB,GAAiB,WAAW,CAAC,GAAG,CACxD,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,KAAmB,CACjD,CAAC;YAEF,aAAa,CAAC,IAAI,CAChB,IAAI,CAAC,WAAW,CAAC,SAAS,CACxB,oBAAoB,EACpB,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,kBAAkB,CACnB,CACF,CAAC;SACH;QAED,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC1D,MAAM,wBAAwB,GAAG,CAAC,CAAC,OAAO,CACxC,gBAAgB,EAChB,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,qBAAqB,CACnD,CAAC;QAEF,OAAO,gBAAgB,CACrB,MAAM,EACN,QAAQ,EACR,wBAAwB,EACxB,SAAS,EACT,IAAI,CAAC,OAAO,EACZ,aAAa,EACb,UAAU,CACX,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,MAAsB,EACtB,OAAc,EACd,QAAe,EACf,SAAqB,EACrB,UAAiB,EACjB,SAAoB,EACpB,aAAgC,EAChC,UAA4C,EAC5C,kBAAuD,EACvD,WAAsB;QAEtB,4EAA4E;QAC5E,kFAAkF;QAClF,oCAAoC;QACpC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,qBAAqB,CACpD,MAAM,EACN,aAAa,CACd,CAAC;QAEF,MAAM,oBAAoB,GAAG,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC;QACpD,MAAM,mBAAmB,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5D,MAAM,mBAAmB,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5D,MAAM,kBAAkB,GAAG,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/D,MAAM,wBAAwB,GAC5B,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;YAClC,CAAC,oBAAoB,IAAI,kBAAkB,CAAC,CAAC;QAC/C,MAAM,oBAAoB,GACxB,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;YACxD,SAAS,KAAK,SAAS,CAAC,WAAW,CAAC;QAEtC,MAAM,aAAa,GAA+B,EAAE,CAAC;QAErD,mEAAmE;QACnE,IAAI,mBAAmB,IAAI,oBAAoB,EAAE;YAC/C,GAAG,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,mBAAmB,CAAC,CAAC;YACxD,aAAa,CAAC,IAAI,CAChB,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAC/B,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,UAAU,CACX,CACF,CAAC;SACH;QAED,qGAAqG;QACrG,IAAI,kBAAkB,IAAI,CAAC,mBAAmB,IAAI,oBAAoB,CAAC,EAAE;YACvE,GAAG,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,mBAAmB,CAAC,CAAC;YACxD,aAAa,CAAC,IAAI,CAChB,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAC/B,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,WAAW,CACZ,CACF,CAAC;SACH;QAED,2BAA2B;QAC3B,yGAAyG;QACzG,0BAA0B;QAC1B,IAAI,wBAAwB,IAAI,oBAAoB,EAAE;YACpD,GAAG,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,4BAA4B,CAAC,CAAC;YACjE,aAAa,CAAC,IAAI,CAChB,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAClC,OAAO,EACP,QAAQ,EACR,OAAO,EACP,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,kBAAkB,CACnB,CACF,CAAC;SACH;QAED,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAE1D,MAAM,wBAAwB,GAA0B,EAAE,CAAC;QAC3D,MAAM,iBAAiB,GAAwC,EAAE,CAAC;QAClE,gBAAgB,CAAC,OAAO,CAAC,CAAC,cAAc,EAAE,EAAE;YAC1C,wBAAwB,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,qBAAqB,CAAC,CAAC;YACvE,IAAI,cAAc,CAAC,cAAc,EAAE;gBACjC,iBAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;aACvD;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,wBAAwB,CAAC,MAAM,KAAK,CAAC,EAAE;YACzC,GAAG,CAAC,IAAI,CAAC,EAAE,wBAAwB,EAAE,EAAE,0BAA0B,CAAC,CAAC;YACnE,OAAO,IAAI,CAAC;SACb;QAED,0FAA0F;QAC1F,MAAM,aAAa,GAAG,MAAM,gBAAgB,CAC1C,MAAM,EACN,QAAQ,EACR,wBAAwB,EACxB,SAAS,EACT,IAAI,CAAC,OAAO,EACZ,aAAa,EACb,UAAU,CACX,CAAC;QAEF,IAAI,aAAa,EAAE;YACjB,IAAI,CAAC,wBAAwB,CAAC,aAAa,EAAE,iBAAiB,CAAC,CAAC;SACjE;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;IAEO,YAAY,CAAC,SAAoB;QACvC,OAAO,SAAS,KAAK,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC;IACtE,CAAC;IAEO,+BAA+B,CACrC,OAAc,EACd,QAAe,EACf,SAAoB;QAEpB,OAAO,GAAG,OAAO,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,IAAI,IAAI,CAAC,YAAY,CAC9D,SAAS,CACV,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;IACtB,CAAC;IAEO,mCAAmC,CACzC,SAAoB,EACpB,MAAsB,EACtB,aAAuB;QAEvB,IAAI,SAAS,KAAK,SAAS,CAAC,WAAW,EAAE;YACvC,OAAO;gBACL,UAAU,EAAE,MAAM,CAAC,QAAQ;gBAC3B,WAAW,EAAE,aAAa;aAC3B,CAAC;SACH;aAAM;YACL,OAAO;gBACL,UAAU,EAAE,aAAa;gBACzB,WAAW,EAAE,MAAM,CAAC,QAAQ;aAC7B,CAAC;SACH;IACH,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,sDAAsD;QACtD,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEtC,wFAAwF;QACxF,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC;QAElE,MAAM,CAAC,SAAS,CACd,cAAc,EACd,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,EAC/B,gBAAgB,CAAC,YAAY,CAC9B,CAAC;QAEF,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,KAAK,CAAC,YAAY,CACxB,WAAsB,EACtB,WAAkB,EAClB,UAAiB,EACjB,cAA+B;QAI/B,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAElC,MAAM,cAAc,GAAG,4BAA4B,CACjD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,cAAc,EACnB,cAAc,CACf,CAAC;QACF,MAAM,cAAc,GAAG,uBAAuB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7D,MAAM,6BAA6B,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,CAAC;YACtE,CAAC,CAAC,+BAA+B,CAC7B,UAAU,EACV,IAAI,CAAC,cAAc,EACnB,cAAc,CACf;YACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1B,MAAM,8BAA8B,GAAG,CAAC,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC;YACxE,CAAC,CAAC,+BAA+B,CAC7B,WAAW,EACX,IAAI,CAAC,cAAc,EACnB,cAAc,CACf;YACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAE1B,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,CAAC,GAC9D,MAAM,OAAO,CAAC,GAAG,CAAC;YAChB,cAAc;YACd,6BAA6B;YAC7B,8BAA8B;SAC/B,CAAC,CAAC;QAEL,MAAM,KAAK,GAA8B;YACvC,OAAO,EAAE,OAAO;YAChB,sBAAsB,EAAE,sBAAsB;YAC9C,uBAAuB,EAAE,uBAAuB;SACjD,CAAC;QAEF,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,aAAa,CAAC;YAC7D,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,WAAW;YACX,KAAK;YACL,WAAW;YACX,UAAU;YACV,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,cAAc,EAAE,cAAc;SAC/B,CAAC,CAAC;QAEH,MAAM,yBAAyB,GAC7B,IAAI,CAAC,yBAAyB,CAAC,aAAa,CAAC;YAC3C,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,WAAW;YACX,KAAK;YACL,WAAW;YACX,UAAU;YACV,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,cAAc,EAAE,cAAc;SAC/B,CAAC,CAAC;QAEL,MAAM,CAAC,UAAU,EAAE,kBAAkB,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACzD,iBAAiB;YACjB,yBAAyB;SAC1B,CAAC,CAAC;QAEH,MAAM,CAAC,SAAS,CACd,kBAAkB,EAClB,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,EAC3B,gBAAgB,CAAC,YAAY,CAC9B,CAAC;QAEF,OAAO,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC;IAC1C,CAAC;IAED,sGAAsG;IACtG,yFAAyF;IACzF,2BAA2B;IACnB,qBAAqB,CAC3B,MAAsB,EACtB,aAAgC;QAEhC,MAAM,EAAE,mBAAmB,EAAE,GAAG,aAAa,CAAC;QAC9C,MAAM,QAAQ,GAAG,EAAE,CAAC;QACpB,MAAM,OAAO,GAAG,EAAE,CAAC;QAEnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG,mBAAmB,EAAE,CAAC,EAAE,EAAE;YACnD,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC;YACvC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,GAAG,mBAAmB,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;SAC3E;QAED,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEO,KAAK,CAAC,+BAA+B,CAC3C,KAA2C,EAC3C,iBAAoC,EACpC,oBAA0C;QAE1C,MAAM,EACJ,WAAW,EAAE,EAAE,SAAS,EAAE,iBAAiB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,EACzE,mBAAmB,EAAE,kBAAkB,GACxC,GAAG,iBAAiB,CAAC;QAEtB,MAAM,oBAAoB,GAAG,oBAAoB,CAAC,oBAAoB,CAAC;QACvE,MAAM,mBAAmB,GACvB,oBAAoB,CAAC,qBAAqB,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACzE,MAAM,oBAAoB,GACxB,oBAAoB,CAAC,sBAAsB,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACtE,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,CACjE,mBAAmB,EACnB,oBAAoB,CACrB,CAAC;QACF,MAAM,UAAU,GAAG,mBAAmB,CAAC,QAAQ,CAAC,OAAO,CAAC,WAAW,CACjE,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CACtC,CAAC;QACF,OAAO;YACL,GAAG,UAAU,CAAC,wBAAwB,CACpC,KAAK,EACL;gBACE,SAAS;gBACT,iBAAiB;gBACjB,2BAA2B,EAAE,QAAQ;gBACrC,gBAAgB;aACjB,EACD,QAAQ,CAAC,WAAW,CAAC;gBACnB,IAAI,EAAE,oBAAoB,CAAC,IAAI;gBAC/B,SAAS,EAAE,oBAAoB,CAAC,SAAS;gBACzC,SAAS,EAAE,oBAAoB,CAAC,SAAS;gBACzC,OAAO,EAAE,UAAU;oBACjB,CAAC,CAAC,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE;oBACzC,CAAC,CAAC,oBAAoB,CAAC,QAAQ,CAAC,QAAQ,EAAE;gBAC5C,OAAO,EAAE,UAAU;oBACjB,CAAC,CAAC,oBAAoB,CAAC,QAAQ,CAAC,QAAQ,EAAE;oBAC1C,CAAC,CAAC,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,EAAE;gBAC3C,gBAAgB,EAAE,KAAK;aACxB,CAAC,EACF,kBAAkB,EAClB,aAAa,CAAC,eAAe,EAC7B,aAAa,CAAC,gBAAgB,CAC/B;YACD,EAAE,EAAE,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC;SAC3C,CAAC;IACJ,CAAC;IAEO,wBAAwB,CAC9B,YAKC,EACD,mBAAwD;QAExD,MAAM,iBAAiB,GAAG,IAAI,GAAG,EAAU,CAAC;QAC5C,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,YAAY,CAAC;QAC9C,CAAC,CAAC,YAAY,CAAC;aACZ,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE;YACvB,MAAM,EAAE,aAAa,EAAE,GAAG,WAAW,CAAC;YACtC,OAAO,aAAa,CAAC;QACvB,CAAC,CAAC;aACD,OAAO,CAAC,CAAC,OAAe,EAAE,EAAE;YAC3B,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;QAEL,KAAK,MAAM,gBAAgB,IAAI,mBAAmB,EAAE;YAClD,MAAM,EAAE,QAAQ,EAAE,GAAG,gBAAgB,CAAC;YACtC,CAAC,CAAC,KAAK,CACL,gBAAgB,CAAC,UAAU,EAC3B,CAAC,KAAe,EAAE,aAAqB,EAAE,EAAE;gBACzC,MAAM,QAAQ,GACZ,CAAC,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAC9B,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CAC7C,GAAG,CAAC,CAAC;gBACR,MAAM,CAAC,SAAS,CACd,CAAC,CAAC,UAAU,CAAC,GAAG,QAAQ,GAAG,aAAa,EAAE,CAAC,EAC3C,QAAQ,EACR,gBAAgB,CAAC,KAAK,CACvB,CAAC;YACJ,CAAC,CACF,CAAC;SACH;QAED,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,IAAI,aAAa,GAAG,KAAK,CAAC;QAC1B,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE;YACtC,IAAI,WAAW,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,EAAE;gBACxC,UAAU,GAAG,IAAI,CAAC;aACnB;YACD,IAAI,WAAW,CAAC,QAAQ,KAAK,QAAQ,CAAC,EAAE,EAAE;gBACxC,UAAU,GAAG,IAAI,CAAC;aACnB;YACD,IAAI,WAAW,CAAC,QAAQ,KAAK,QAAQ,CAAC,KAAK,EAAE;gBAC3C,aAAa,GAAG,IAAI,CAAC;aACtB;SACF;QAED,IAAI,aAAa,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,EAAE;YAC/C,IAAI,UAAU,IAAI,UAAU,EAAE;gBAC5B,MAAM,CAAC,SAAS,CACd,2BAA2B,EAC3B,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;gBACF,MAAM,CAAC,SAAS,CACd,oCAAoC,IAAI,CAAC,OAAO,EAAE,EAClD,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;iBAAM,IAAI,UAAU,EAAE;gBACrB,MAAM,CAAC,SAAS,CAAC,sBAAsB,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBACpE,MAAM,CAAC,SAAS,CACd,+BAA+B,IAAI,CAAC,OAAO,EAAE,EAC7C,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;iBAAM,IAAI,UAAU,EAAE;gBACrB,MAAM,CAAC,SAAS,CAAC,sBAAsB,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBACpE,MAAM,CAAC,SAAS,CACd,+BAA+B,IAAI,CAAC,OAAO,EAAE,EAC7C,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;SACF;aAAM,IAAI,UAAU,IAAI,UAAU,EAAE;YACnC,MAAM,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;YACjE,MAAM,CAAC,SAAS,CACd,4BAA4B,IAAI,CAAC,OAAO,EAAE,EAC1C,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;SACH;aAAM,IAAI,aAAa,EAAE;YACxB,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC3B,MAAM,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC/D,MAAM,CAAC,SAAS,CACd,0BAA0B,IAAI,CAAC,OAAO,EAAE,EACxC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;iBAAM;gBACL,MAAM,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC1D,MAAM,CAAC,SAAS,CACd,qBAAqB,IAAI,CAAC,OAAO,EAAE,EACnC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;SACF;aAAM,IAAI,UAAU,EAAE;YACrB,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC3B,MAAM,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC5D,MAAM,CAAC,SAAS,CACd,uBAAuB,IAAI,CAAC,OAAO,EAAE,EACrC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;iBAAM;gBACL,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBACvD,MAAM,CAAC,SAAS,CACd,kBAAkB,IAAI,CAAC,OAAO,EAAE,EAChC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;SACF;aAAM,IAAI,UAAU,EAAE;YACrB,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC3B,MAAM,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC5D,MAAM,CAAC,SAAS,CACd,uBAAuB,IAAI,CAAC,OAAO,EAAE,EACrC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;iBAAM;gBACL,MAAM,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBACvD,MAAM,CAAC,SAAS,CACd,kBAAkB,IAAI,CAAC,OAAO,EAAE,EAChC,CAAC,EACD,gBAAgB,CAAC,KAAK,CACvB,CAAC;aACH;SACF;IACH,CAAC;IAEO,qBAAqB,CAC3B,QAAkB,EAClB,YAAkB,EAClB,UAAmB;QAEnB,MAAM,iBAAiB,GAAG,QAAQ,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAC1E,MAAM,iBAAiB,GAAG,QAAQ,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAE1E,uGAAuG;QACvG,+EAA+E;QAC/E,IACE,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,iBAAiB,CAAC;YACjD,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC,EAC9C;YACA,OAAO,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SAC3B;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;QACpD,IAAI,YAAY,GAAG,IAAI,QAAQ,CAC7B,aAAa,CAAC,eAAe,CAC3B,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,IAAI,CACL,EACD,aAAa,CAAC,eAAe,CAC3B,YAAY,EACZ,iBAAiB,EACjB,SAAS,EACT,IAAI,CACL,CACF,CAAC;QACF,IAAI,CAAC,UAAU;YAAE,YAAY,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC;QACtD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEM,KAAK,CAAC,wBAAwB,CACnC,WAAmB,EACnB,SAAoB,EACpB,MAAsB,EACtB,KAAqB;QAErB,IAAI;YACF,MAAM,aAAa,GACjB,SAAS,KAAK,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;YACvD,IAAI,OAAO,CAAC;YACZ,IAAI,aAAa,CAAC,QAAQ,CAAC,QAAQ,EAAE;gBACnC,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;aACvD;iBAAM;gBACL,MAAM,aAAa,GAAG,cAAc,CAAC,OAAO,CAC1C,aAAa,CAAC,QAAQ,CAAC,OAAO,EAC9B,IAAI,CAAC,QAAQ,CACd,CAAC;gBACF,OAAO,GAAG,MAAM,aAAa,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;aACtD;YACD,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;SACvE;QAAC,OAAO,CAAC,EAAE;YACV,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,mCAAmC,CAAC,CAAC;YAClD,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAEO,aAAa,CAAC,QAAkB;QACtC,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACpE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC;YACrC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC;QACvB,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACxE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC;YACvC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;QACzB,OAAO,IAAI,QAAQ,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IACpD,CAAC;IAEO,qBAAqB;QAC3B,OAAO,KAAK,CACV,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE;YACpB,IAAI,OAAO,GAAG,CAAC,EAAE;gBACf,GAAG,CAAC,IAAI,CAAC,4BAA4B,OAAO,EAAE,CAAC,CAAC;aACjD;YACD,OAAO,IAAI,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;QACxC,CAAC,EACD;YACE,OAAO,EAAE,CAAC;YACV,UAAU,EAAE,GAAG;YACf,UAAU,EAAE,IAAI;SACjB,CACF,CAAC;IACJ,CAAC;CACF"}