Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "../BaseLogic.sol";
import "../IRiskManager.sol";
import "../PToken.sol";
import "../Interfaces.sol";
import "../Utils.sol";


/// @notice Definition of callback method that deferLiquidityCheck will invoke on your contract
interface IDeferredLiquidityCheck {
    function onDeferredLiquidityCheck(bytes memory data) external;
}


/// @notice Batch executions, liquidity check deferrals, and interfaces to fetch prices and account liquidity
contract Exec is BaseLogic {
    constructor(bytes32 moduleGitCommit_) BaseLogic(MODULEID__EXEC, moduleGitCommit_) {}

    /// @notice Single item in a batch request
    struct EulerBatchItem {
        bool allowError;
        address proxyAddr;
        bytes data;
    }

    /// @notice Single item in a batch response
    struct EulerBatchItemResponse {
        bool success;
        bytes result;
    }

    /// @notice Error containing results of a simulated batch dispatch
    error BatchDispatchSimulation(EulerBatchItemResponse[] simulation);

    // Accessors

    /// @notice Compute aggregate liquidity for an account
    /// @param account User address
    /// @return status Aggregate liquidity (sum of all entered assets)
    function liquidity(address account) external staticDelegate returns (IRiskManager.LiquidityStatus memory status) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER,
                                                 abi.encodeWithSelector(IRiskManager.computeLiquidity.selector, account));

        (status) = abi.decode(result, (IRiskManager.LiquidityStatus));
    }

    /// @notice Compute detailed liquidity for an account, broken down by asset
    /// @param account User address
    /// @return assets List of user's entered assets and each asset's corresponding liquidity
    function detailedLiquidity(address account) public staticDelegate returns (IRiskManager.AssetLiquidity[] memory assets) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER,
                                                 abi.encodeWithSelector(IRiskManager.computeAssetLiquidities.selector, account));

        (assets) = abi.decode(result, (IRiskManager.AssetLiquidity[]));
    }

    /// @notice Retrieve Euler's view of an asset's price
    /// @param underlying Token address
    /// @return twap Time-weighted average price
    /// @return twapPeriod TWAP duration, either the twapWindow value in AssetConfig, or less if that duration not available
    function getPrice(address underlying) external staticDelegate returns (uint twap, uint twapPeriod) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER,
                                                 abi.encodeWithSelector(IRiskManager.getPrice.selector, underlying));

        (twap, twapPeriod) = abi.decode(result, (uint, uint));
    }

    /// @notice Retrieve Euler's view of an asset's price, as well as the current marginal price on uniswap
    /// @param underlying Token address
    /// @return twap Time-weighted average price
    /// @return twapPeriod TWAP duration, either the twapWindow value in AssetConfig, or less if that duration not available
    /// @return currPrice The current marginal price on uniswap3 (informational: not used anywhere in the Euler protocol)
    function getPriceFull(address underlying) external staticDelegate returns (uint twap, uint twapPeriod, uint currPrice) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER,
                                                 abi.encodeWithSelector(IRiskManager.getPriceFull.selector, underlying));

        (twap, twapPeriod, currPrice) = abi.decode(result, (uint, uint, uint));
    }


    // Custom execution methods

    /// @notice Defer liquidity checking for an account, to perform rebalancing, flash loans, etc. msg.sender must implement IDeferredLiquidityCheck
    /// @param account The account to defer liquidity for. Usually address(this), although not always
    /// @param data Passed through to the onDeferredLiquidityCheck() callback, so contracts don't need to store transient data in storage
    function deferLiquidityCheck(address account, bytes memory data) external reentrantOK {
        address msgSender = unpackTrailingParamMsgSender();

        require(accountLookup[account].deferLiquidityStatus == DEFERLIQUIDITY__NONE, "e/defer/reentrancy");
        accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__CLEAN;

        IDeferredLiquidityCheck(msgSender).onDeferredLiquidityCheck(data);

        uint8 status = accountLookup[account].deferLiquidityStatus;
        accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__NONE;

        if (status == DEFERLIQUIDITY__DIRTY) checkLiquidity(account);
    }

    /// @notice Execute several operations in a single transaction
    /// @param items List of operations to execute
    /// @param deferLiquidityChecks List of user accounts to defer liquidity checks for
    function batchDispatch(EulerBatchItem[] calldata items, address[] calldata deferLiquidityChecks) external reentrantOK {
        doBatchDispatch(items, deferLiquidityChecks, false);
    }

    /// @notice Call batch dispatch, but instruct it to revert with the responses, before the liquidity checks.
    /// @param items List of operations to execute
    /// @param deferLiquidityChecks List of user accounts to defer liquidity checks for
    /// @dev During simulation all batch items are executed, regardless of the `allowError` flag
    function batchDispatchSimulate(EulerBatchItem[] calldata items, address[] calldata deferLiquidityChecks) external reentrantOK {
        doBatchDispatch(items, deferLiquidityChecks, true);

        revert("e/batch/simulation-did-not-revert");
    }


    // Average liquidity tracking

    /// @notice Enable average liquidity tracking for your account. Operations will cost more gas, but you may get additional benefits when performing liquidations
    /// @param subAccountId subAccountId 0 for primary, 1-255 for a sub-account. 
    /// @param delegate An address of another account that you would allow to use the benefits of your account's average liquidity (use the null address if you don't care about this). The other address must also reciprocally delegate to your account.
    /// @param onlyDelegate Set this flag to skip tracking average liquidity and only set the delegate.
    function trackAverageLiquidity(uint subAccountId, address delegate, bool onlyDelegate) external nonReentrant {
        address msgSender = unpackTrailingParamMsgSender();
        address account = getSubAccount(msgSender, subAccountId);
        require(account != delegate, "e/track-liquidity/self-delegation");

        emit DelegateAverageLiquidity(account, delegate);
        accountLookup[account].averageLiquidityDelegate = delegate;

        if (onlyDelegate) return;

        emit TrackAverageLiquidity(account);

        accountLookup[account].lastAverageLiquidityUpdate = uint40(block.timestamp);
        accountLookup[account].averageLiquidity = 0;
    }

    /// @notice Disable average liquidity tracking for your account and remove delegate
    /// @param subAccountId subAccountId 0 for primary, 1-255 for a sub-account
    function unTrackAverageLiquidity(uint subAccountId) external nonReentrant {
        address msgSender = unpackTrailingParamMsgSender();
        address account = getSubAccount(msgSender, subAccountId);

        emit UnTrackAverageLiquidity(account);
        emit DelegateAverageLiquidity(account, address(0));

        accountLookup[account].lastAverageLiquidityUpdate = 0;
        accountLookup[account].averageLiquidity = 0;
        accountLookup[account].averageLiquidityDelegate = address(0);
    }

    /// @notice Retrieve the average liquidity for an account
    /// @param account User account (xor in subAccountId, if applicable)
    /// @return The average liquidity, in terms of the reference asset, and post risk-adjustment
    function getAverageLiquidity(address account) external nonReentrant returns (uint) {
        return getUpdatedAverageLiquidity(account);
    }

    /// @notice Retrieve the average liquidity for an account or a delegate account, if set
    /// @param account User account (xor in subAccountId, if applicable)
    /// @return The average liquidity, in terms of the reference asset, and post risk-adjustment
    function getAverageLiquidityWithDelegate(address account) external nonReentrant returns (uint) {
        return getUpdatedAverageLiquidityWithDelegate(account);
    }

    /// @notice Retrieve the account which delegates average liquidity for an account, if set
    /// @param account User account (xor in subAccountId, if applicable)
    /// @return The average liquidity delegate account
    function getAverageLiquidityDelegateAccount(address account) external view returns (address) {
        address delegate = accountLookup[account].averageLiquidityDelegate;
        return accountLookup[delegate].averageLiquidityDelegate == account ? delegate : address(0);
    }




    // PToken wrapping/unwrapping

    /// @notice Transfer underlying tokens from sender's wallet into the pToken wrapper. Allowance should be set for the euler address.
    /// @param underlying Token address
    /// @param amount The amount to wrap in underlying units
    function pTokenWrap(address underlying, uint amount) external nonReentrant {
        address msgSender = unpackTrailingParamMsgSender();

        emit PTokenWrap(underlying, msgSender, amount);

        address pTokenAddr = reversePTokenLookup[underlying];
        require(pTokenAddr != address(0), "e/exec/ptoken-not-found");

        {
            uint origBalance = IERC20(underlying).balanceOf(pTokenAddr);
            Utils.safeTransferFrom(underlying, msgSender, pTokenAddr, amount);
            uint newBalance = IERC20(underlying).balanceOf(pTokenAddr);
            require(newBalance == origBalance + amount, "e/exec/ptoken-transfer-mismatch");
        }

        PToken(pTokenAddr).claimSurplus(msgSender);
    }

    /// @notice Transfer underlying tokens from the pToken wrapper to the sender's wallet.
    /// @param underlying Token address
    /// @param amount The amount to unwrap in underlying units
    function pTokenUnWrap(address underlying, uint amount) external nonReentrant {
        address msgSender = unpackTrailingParamMsgSender();

        emit PTokenUnWrap(underlying, msgSender, amount);

        address pTokenAddr = reversePTokenLookup[underlying];
        require(pTokenAddr != address(0), "e/exec/ptoken-not-found");

        PToken(pTokenAddr).forceUnwrap(msgSender, amount);
    }

    /// @notice Apply EIP2612 signed permit on a target token from sender to euler contract
    /// @param token Token address
    /// @param value Allowance value
    /// @param deadline Permit expiry timestamp
    /// @param v secp256k1 signature v
    /// @param r secp256k1 signature r
    /// @param s secp256k1 signature s
    function usePermit(address token, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
        require(underlyingLookup[token].eTokenAddress != address(0), "e/exec/market-not-activated");
        address msgSender = unpackTrailingParamMsgSender();

        IERC20Permit(token).permit(msgSender, address(this), value, deadline, v, r, s);
    }

    /// @notice Apply DAI like (allowed) signed permit on a target token from sender to euler contract
    /// @param token Token address
    /// @param nonce Sender nonce
    /// @param expiry Permit expiry timestamp
    /// @param allowed If true, set unlimited allowance, otherwise set zero allowance
    /// @param v secp256k1 signature v
    /// @param r secp256k1 signature r
    /// @param s secp256k1 signature s
    function usePermitAllowed(address token, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external nonReentrant {
        require(underlyingLookup[token].eTokenAddress != address(0), "e/exec/market-not-activated");
        address msgSender = unpackTrailingParamMsgSender();

        IERC20Permit(token).permit(msgSender, address(this), nonce, expiry, allowed, v, r, s);
    }

    /// @notice Apply allowance to tokens expecting the signature packed in a single bytes param
    /// @param token Token address
    /// @param value Allowance value
    /// @param deadline Permit expiry timestamp
    /// @param signature secp256k1 signature encoded as rsv
    function usePermitPacked(address token, uint256 value, uint256 deadline, bytes calldata signature) external nonReentrant {
        require(underlyingLookup[token].eTokenAddress != address(0), "e/exec/market-not-activated");
        address msgSender = unpackTrailingParamMsgSender();

        IERC20Permit(token).permit(msgSender, address(this), value, deadline, signature);
    }

    /// @notice Execute a staticcall to an arbitrary address with an arbitrary payload.
    /// @param contractAddress Address of the contract to call
    /// @param payload Encoded call payload
    /// @return result Encoded return data
    /// @dev Intended to be used in static-called batches, to e.g. provide detailed information about the impacts of the simulated operation.
    function doStaticCall(address contractAddress, bytes memory payload) external view returns (bytes memory) {
        (bool success, bytes memory result) = contractAddress.staticcall(payload);
        if (!success) revertBytes(result);

        assembly {
            return(add(32, result), mload(result))
        }
    }

    function doBatchDispatch(EulerBatchItem[] calldata items, address[] calldata deferLiquidityChecks, bool revertResponse) private {
        address msgSender = unpackTrailingParamMsgSender();

        for (uint i = 0; i < deferLiquidityChecks.length; ++i) {
            address account = deferLiquidityChecks[i];

            require(accountLookup[account].deferLiquidityStatus == DEFERLIQUIDITY__NONE, "e/batch/reentrancy");
            accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__CLEAN;
        }


        EulerBatchItemResponse[] memory response;
        if (revertResponse) response = new EulerBatchItemResponse[](items.length);

        for (uint i = 0; i < items.length; ++i) {
            EulerBatchItem calldata item = items[i];
            address proxyAddr = item.proxyAddr;

            uint32 moduleId = trustedSenders[proxyAddr].moduleId;
            address moduleImpl = trustedSenders[proxyAddr].moduleImpl;

            require(moduleId != 0, "e/batch/unknown-proxy-addr");
            require(moduleId <= MAX_EXTERNAL_MODULEID, "e/batch/call-to-internal-module");

            if (moduleImpl == address(0)) moduleImpl = moduleLookup[moduleId];
            require(moduleImpl != address(0), "e/batch/module-not-installed");

            bytes memory inputWrapped = abi.encodePacked(item.data, uint160(msgSender), uint160(proxyAddr));
            (bool success, bytes memory result) = moduleImpl.delegatecall(inputWrapped);

            if (revertResponse) {
                EulerBatchItemResponse memory r = response[i];
                r.success = success;
                r.result = result;
            } else if (!(success || item.allowError)) {
                revertBytes(result);
            }
        }

        if (revertResponse) revert BatchDispatchSimulation(response);

        for (uint i = 0; i < deferLiquidityChecks.length; ++i) {
            address account = deferLiquidityChecks[i];

            uint8 status = accountLookup[account].deferLiquidityStatus;
            accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__NONE;

            if (status == DEFERLIQUIDITY__DIRTY) checkLiquidity(account);
        }
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./BaseModule.sol";
import "./BaseIRM.sol";
import "./Interfaces.sol";
import "./Utils.sol";
import "./vendor/RPow.sol";
import "./IRiskManager.sol";


abstract contract BaseLogic is BaseModule {
    constructor(uint moduleId_, bytes32 moduleGitCommit_) BaseModule(moduleId_, moduleGitCommit_) {}


    // Account auth

    function getSubAccount(address primary, uint subAccountId) internal pure returns (address) {
        require(subAccountId < 256, "e/sub-account-id-too-big");
        return address(uint160(primary) ^ uint160(subAccountId));
    }

    function isSubAccountOf(address primary, address subAccount) internal pure returns (bool) {
        return (uint160(primary) | 0xFF) == (uint160(subAccount) | 0xFF);
    }



    // Entered markets array

    function getEnteredMarketsArray(address account) internal view returns (address[] memory) {
        uint32 numMarketsEntered = accountLookup[account].numMarketsEntered;
        address firstMarketEntered = accountLookup[account].firstMarketEntered;

        address[] memory output = new address[](numMarketsEntered);
        if (numMarketsEntered == 0) return output;

        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        output[0] = firstMarketEntered;

        for (uint i = 1; i < numMarketsEntered; ++i) {
            output[i] = markets[i];
        }

        return output;
    }

    function isEnteredInMarket(address account, address underlying) internal view returns (bool) {
        uint32 numMarketsEntered = accountLookup[account].numMarketsEntered;
        address firstMarketEntered = accountLookup[account].firstMarketEntered;

        if (numMarketsEntered == 0) return false;
        if (firstMarketEntered == underlying) return true;

        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        for (uint i = 1; i < numMarketsEntered; ++i) {
            if (markets[i] == underlying) return true;
        }

        return false;
    }

    function doEnterMarket(address account, address underlying) internal {
        AccountStorage storage accountStorage = accountLookup[account];

        uint32 numMarketsEntered = accountStorage.numMarketsEntered;
        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];

        if (numMarketsEntered != 0) {
            if (accountStorage.firstMarketEntered == underlying) return; // already entered
            for (uint i = 1; i < numMarketsEntered; i++) {
                if (markets[i] == underlying) return; // already entered
            }
        }

        require(numMarketsEntered < MAX_ENTERED_MARKETS, "e/too-many-entered-markets");

        if (numMarketsEntered == 0) accountStorage.firstMarketEntered = underlying;
        else markets[numMarketsEntered] = underlying;

        accountStorage.numMarketsEntered = numMarketsEntered + 1;

        emit EnterMarket(underlying, account);
    }

    // Liquidity check must be done by caller after calling this

    function doExitMarket(address account, address underlying) internal {
        AccountStorage storage accountStorage = accountLookup[account];

        uint32 numMarketsEntered = accountStorage.numMarketsEntered;
        address[MAX_POSSIBLE_ENTERED_MARKETS] storage markets = marketsEntered[account];
        uint searchIndex = type(uint).max;

        if (numMarketsEntered == 0) return; // already exited

        if (accountStorage.firstMarketEntered == underlying) {
            searchIndex = 0;
        } else {
            for (uint i = 1; i < numMarketsEntered; i++) {
                if (markets[i] == underlying) {
                    searchIndex = i;
                    break;
                }
            }

            if (searchIndex == type(uint).max) return; // already exited
        }

        uint lastMarketIndex = numMarketsEntered - 1;

        if (searchIndex != lastMarketIndex) {
            if (searchIndex == 0) accountStorage.firstMarketEntered = markets[lastMarketIndex];
            else markets[searchIndex] = markets[lastMarketIndex];
        }

        accountStorage.numMarketsEntered = uint32(lastMarketIndex);

        if (lastMarketIndex != 0) markets[lastMarketIndex] = address(0); // zero out for storage refund

        emit ExitMarket(underlying, account);
    }



    // AssetConfig

    function resolveAssetConfig(address underlying) internal view returns (AssetConfig memory) {
        AssetConfig memory config = underlyingLookup[underlying];
        require(config.eTokenAddress != address(0), "e/market-not-activated");

        if (config.borrowFactor == type(uint32).max) config.borrowFactor = DEFAULT_BORROW_FACTOR;
        if (config.twapWindow == type(uint24).max) config.twapWindow = DEFAULT_TWAP_WINDOW_SECONDS;

        return config;
    }


    // AssetCache

    struct AssetCache {
        address underlying;

        uint112 totalBalances;
        uint144 totalBorrows;

        uint96 reserveBalance;

        uint interestAccumulator;

        uint40 lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals;
        uint32 interestRateModel;
        int96 interestRate;
        uint32 reserveFee;
        uint16 pricingType;
        uint32 pricingParameters;

        uint poolSize; // result of calling balanceOf on underlying (in external units)

        uint underlyingDecimalsScaler;
        uint maxExternalAmount;
    }

    function initAssetCache(address underlying, AssetStorage storage assetStorage, AssetCache memory assetCache) internal view returns (bool dirty) {
        dirty = false;

        assetCache.underlying = underlying;

        // Storage loads

        assetCache.lastInterestAccumulatorUpdate = assetStorage.lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals = assetCache.underlyingDecimals = assetStorage.underlyingDecimals;
        assetCache.interestRateModel = assetStorage.interestRateModel;
        assetCache.interestRate = assetStorage.interestRate;
        assetCache.reserveFee = assetStorage.reserveFee;
        assetCache.pricingType = assetStorage.pricingType;
        assetCache.pricingParameters = assetStorage.pricingParameters;

        assetCache.reserveBalance = assetStorage.reserveBalance;

        assetCache.totalBalances = assetStorage.totalBalances;
        assetCache.totalBorrows = assetStorage.totalBorrows;

        assetCache.interestAccumulator = assetStorage.interestAccumulator;

        // Derived state

        unchecked {
            assetCache.underlyingDecimalsScaler = 10**(18 - underlyingDecimals);
            assetCache.maxExternalAmount = MAX_SANE_AMOUNT / assetCache.underlyingDecimalsScaler;
        }

        uint poolSize = callBalanceOf(assetCache, address(this));
        if (poolSize <= assetCache.maxExternalAmount) {
            unchecked { assetCache.poolSize = poolSize * assetCache.underlyingDecimalsScaler; }
        } else {
            assetCache.poolSize = 0;
        }

        // Update interest accumulator and reserves

        if (block.timestamp != assetCache.lastInterestAccumulatorUpdate) {
            dirty = true;

            uint deltaT = block.timestamp - assetCache.lastInterestAccumulatorUpdate;

            // Compute new values

            uint newInterestAccumulator = (RPow.rpow(uint(int(assetCache.interestRate) + 1e27), deltaT, 1e27) * assetCache.interestAccumulator) / 1e27;

            uint newTotalBorrows = assetCache.totalBorrows * newInterestAccumulator / assetCache.interestAccumulator;

            uint newReserveBalance = assetCache.reserveBalance;
            uint newTotalBalances = assetCache.totalBalances;

            uint feeAmount = (newTotalBorrows - assetCache.totalBorrows)
                               * (assetCache.reserveFee == type(uint32).max ? DEFAULT_RESERVE_FEE : assetCache.reserveFee)
                               / (RESERVE_FEE_SCALE * INTERNAL_DEBT_PRECISION);

            if (feeAmount != 0) {
                uint poolAssets = assetCache.poolSize + (newTotalBorrows / INTERNAL_DEBT_PRECISION);
                newTotalBalances = poolAssets * newTotalBalances / (poolAssets - feeAmount);
                newReserveBalance += newTotalBalances - assetCache.totalBalances;
            }

            // Store new values in assetCache, only if no overflows will occur

            if (newTotalBalances <= MAX_SANE_AMOUNT && newTotalBorrows <= MAX_SANE_DEBT_AMOUNT) {
                assetCache.totalBorrows = encodeDebtAmount(newTotalBorrows);
                assetCache.interestAccumulator = newInterestAccumulator;
                assetCache.lastInterestAccumulatorUpdate = uint40(block.timestamp);

                if (newTotalBalances != assetCache.totalBalances) {
                    assetCache.reserveBalance = encodeSmallAmount(newReserveBalance);
                    assetCache.totalBalances = encodeAmount(newTotalBalances);
                }
            }
        }
    }

    function loadAssetCache(address underlying, AssetStorage storage assetStorage) internal returns (AssetCache memory assetCache) {
        if (initAssetCache(underlying, assetStorage, assetCache)) {
            assetStorage.lastInterestAccumulatorUpdate = assetCache.lastInterestAccumulatorUpdate;

            assetStorage.underlying = assetCache.underlying; // avoid an SLOAD of this slot
            assetStorage.reserveBalance = assetCache.reserveBalance;

            assetStorage.totalBalances = assetCache.totalBalances;
            assetStorage.totalBorrows = assetCache.totalBorrows;

            assetStorage.interestAccumulator = assetCache.interestAccumulator;
        }
    }

    function loadAssetCacheRO(address underlying, AssetStorage storage assetStorage) internal view returns (AssetCache memory assetCache) {
        require(reentrancyLock == REENTRANCYLOCK__UNLOCKED, "e/ro-reentrancy");
        initAssetCache(underlying, assetStorage, assetCache);
    }

    function internalLoadAssetCacheRO(address underlying, AssetStorage storage assetStorage) internal view returns (AssetCache memory assetCache) {
        initAssetCache(underlying, assetStorage, assetCache);
    }



    // Utils

    function decodeExternalAmount(AssetCache memory assetCache, uint externalAmount) internal pure returns (uint scaledAmount) {
        require(externalAmount <= assetCache.maxExternalAmount, "e/amount-too-large");
        unchecked { scaledAmount = externalAmount * assetCache.underlyingDecimalsScaler; }
    }

    function encodeAmount(uint amount) internal pure returns (uint112) {
        require(amount <= MAX_SANE_AMOUNT, "e/amount-too-large-to-encode");
        return uint112(amount);
    }

    function encodeSmallAmount(uint amount) internal pure returns (uint96) {
        require(amount <= MAX_SANE_SMALL_AMOUNT, "e/small-amount-too-large-to-encode");
        return uint96(amount);
    }

    function encodeDebtAmount(uint amount) internal pure returns (uint144) {
        require(amount <= MAX_SANE_DEBT_AMOUNT, "e/debt-amount-too-large-to-encode");
        return uint144(amount);
    }

    function computeExchangeRate(AssetCache memory assetCache) private pure returns (uint) {
        uint totalAssets = assetCache.poolSize + (assetCache.totalBorrows / INTERNAL_DEBT_PRECISION);
        if (totalAssets == 0 || assetCache.totalBalances == 0) return 1e18;
        return totalAssets * 1e18 / assetCache.totalBalances;
    }

    function underlyingAmountToBalance(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return amount * 1e18 / exchangeRate;
    }

    function underlyingAmountToBalanceRoundUp(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return (amount * 1e18 + (exchangeRate - 1)) / exchangeRate;
    }

    function balanceToUnderlyingAmount(AssetCache memory assetCache, uint amount) internal pure returns (uint) {
        uint exchangeRate = computeExchangeRate(assetCache);
        return amount * exchangeRate / 1e18;
    }

    function callBalanceOf(AssetCache memory assetCache, address account) internal view FREEMEM returns (uint) {
        // We set a gas limit so that a malicious token can't eat up all gas and cause a liquidity check to fail.

        (bool success, bytes memory data) = assetCache.underlying.staticcall{gas: 200000}(abi.encodeWithSelector(IERC20.balanceOf.selector, account));

        // If token's balanceOf() call fails for any reason, return 0. This prevents malicious tokens from causing liquidity checks to fail.
        // If the contract doesn't exist (maybe because selfdestructed), then data.length will be 0 and we will return 0.
        // Data length > 32 is allowed because some legitimate tokens append extra data that can be safely ignored.

        if (!success || data.length < 32) return 0;

        return abi.decode(data, (uint256));
    }

    function updateInterestRate(AssetStorage storage assetStorage, AssetCache memory assetCache) internal {
        uint32 utilisation;

        {
            uint totalBorrows = assetCache.totalBorrows / INTERNAL_DEBT_PRECISION;
            uint poolAssets = assetCache.poolSize + totalBorrows;
            if (poolAssets == 0) utilisation = 0; // empty pool arbitrarily given utilisation of 0
            else utilisation = uint32(totalBorrows * (uint(type(uint32).max) * 1e18) / poolAssets / 1e18);
        }

        bytes memory result = callInternalModule(assetCache.interestRateModel,
                                                 abi.encodeWithSelector(BaseIRM.computeInterestRate.selector, assetCache.underlying, utilisation));

        (int96 newInterestRate) = abi.decode(result, (int96));

        assetStorage.interestRate = assetCache.interestRate = newInterestRate;
    }

    function logAssetStatus(AssetCache memory a) internal {
        emit AssetStatus(a.underlying, a.totalBalances, a.totalBorrows / INTERNAL_DEBT_PRECISION, a.reserveBalance, a.poolSize, a.interestAccumulator, a.interestRate, block.timestamp);
    }



    // Balances

    function increaseBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address account, uint amount) internal {
        assetStorage.users[account].balance = encodeAmount(assetStorage.users[account].balance + amount);

        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(uint(assetCache.totalBalances) + amount);

        updateInterestRate(assetStorage, assetCache);

        emit Deposit(assetCache.underlying, account, amount);
        emitViaProxy_Transfer(eTokenAddress, address(0), account, amount);
    }

    function decreaseBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address account, uint amount) internal {
        uint origBalance = assetStorage.users[account].balance;
        require(origBalance >= amount, "e/insufficient-balance");
        assetStorage.users[account].balance = encodeAmount(origBalance - amount);

        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(assetCache.totalBalances - amount);

        updateInterestRate(assetStorage, assetCache);

        emit Withdraw(assetCache.underlying, account, amount);
        emitViaProxy_Transfer(eTokenAddress, account, address(0), amount);
    }

    function transferBalance(AssetStorage storage assetStorage, AssetCache memory assetCache, address eTokenAddress, address from, address to, uint amount) internal {
        uint origFromBalance = assetStorage.users[from].balance;
        require(origFromBalance >= amount, "e/insufficient-balance");
        uint newFromBalance;
        unchecked { newFromBalance = origFromBalance - amount; }

        assetStorage.users[from].balance = encodeAmount(newFromBalance);
        assetStorage.users[to].balance = encodeAmount(assetStorage.users[to].balance + amount);

        emit Withdraw(assetCache.underlying, from, amount);
        emit Deposit(assetCache.underlying, to, amount);
        emitViaProxy_Transfer(eTokenAddress, from, to, amount);
    }

    function withdrawAmounts(AssetStorage storage assetStorage, AssetCache memory assetCache, address account, uint amount) internal view returns (uint, uint) {
        uint amountInternal;
        if (amount == type(uint).max) {
            amountInternal = assetStorage.users[account].balance;
            amount = balanceToUnderlyingAmount(assetCache, amountInternal);
        } else {
            amount = decodeExternalAmount(assetCache, amount);
            amountInternal = underlyingAmountToBalanceRoundUp(assetCache, amount);
        }

        return (amount, amountInternal);
    }

    // Borrows

    // Returns internal precision

    function getCurrentOwedExact(AssetStorage storage assetStorage, AssetCache memory assetCache, address account, uint owed) internal view returns (uint) {
        // Don't bother loading the user's accumulator
        if (owed == 0) return 0;

        // Can't divide by 0 here: If owed is non-zero, we must've initialised the user's interestAccumulator
        return owed * assetCache.interestAccumulator / assetStorage.users[account].interestAccumulator;
    }

    // When non-zero, we round *up* to the smallest external unit so that outstanding dust in a loan can be repaid.
    // unchecked is OK here since owed is always loaded from storage, so we know it fits into a uint144 (pre-interest accural)
    // Takes and returns 27 decimals precision.

    function roundUpOwed(AssetCache memory assetCache, uint owed) private pure returns (uint) {
        if (owed == 0) return 0;

        unchecked {
            uint scale = INTERNAL_DEBT_PRECISION * assetCache.underlyingDecimalsScaler;
            return (owed + scale - 1) / scale * scale;
        }
    }

    // Returns 18-decimals precision (debt amount is rounded up)

    function getCurrentOwed(AssetStorage storage assetStorage, AssetCache memory assetCache, address account) internal view returns (uint) {
        return roundUpOwed(assetCache, getCurrentOwedExact(assetStorage, assetCache, account, assetStorage.users[account].owed)) / INTERNAL_DEBT_PRECISION;
    }

    function updateUserBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address account) private returns (uint newOwedExact, uint prevOwedExact) {
        prevOwedExact = assetStorage.users[account].owed;

        newOwedExact = getCurrentOwedExact(assetStorage, assetCache, account, prevOwedExact);

        assetStorage.users[account].owed = encodeDebtAmount(newOwedExact);
        assetStorage.users[account].interestAccumulator = assetCache.interestAccumulator;
    }

    function logBorrowChange(AssetCache memory assetCache, address dTokenAddress, address account, uint prevOwed, uint owed) private {
        prevOwed = roundUpOwed(assetCache, prevOwed) / INTERNAL_DEBT_PRECISION;
        owed = roundUpOwed(assetCache, owed) / INTERNAL_DEBT_PRECISION;

        if (owed > prevOwed) {
            uint change = owed - prevOwed;
            emit Borrow(assetCache.underlying, account, change);
            emitViaProxy_Transfer(dTokenAddress, address(0), account, change / assetCache.underlyingDecimalsScaler);
        } else if (prevOwed > owed) {
            uint change = prevOwed - owed;
            emit Repay(assetCache.underlying, account, change);
            emitViaProxy_Transfer(dTokenAddress, account, address(0), change / assetCache.underlyingDecimalsScaler);
        }
    }

    function increaseBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address account, uint amount) internal {
        amount *= INTERNAL_DEBT_PRECISION;

        require(assetCache.pricingType != PRICINGTYPE__FORWARDED || pTokenLookup[assetCache.underlying] == address(0), "e/borrow-not-supported");

        (uint owed, uint prevOwed) = updateUserBorrow(assetStorage, assetCache, account);

        if (owed == 0) doEnterMarket(account, assetCache.underlying);

        owed += amount;

        assetStorage.users[account].owed = encodeDebtAmount(owed);
        assetStorage.totalBorrows = assetCache.totalBorrows = encodeDebtAmount(assetCache.totalBorrows + amount);

        updateInterestRate(assetStorage, assetCache);

        logBorrowChange(assetCache, dTokenAddress, account, prevOwed, owed);
    }

    function decreaseBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address account, uint origAmount) internal {
        uint amount = origAmount * INTERNAL_DEBT_PRECISION;

        (uint owed, uint prevOwed) = updateUserBorrow(assetStorage, assetCache, account);
        uint owedRoundedUp = roundUpOwed(assetCache, owed);

        require(amount <= owedRoundedUp, "e/repay-too-much");
        uint owedRemaining;
        unchecked { owedRemaining = owedRoundedUp - amount; }

        if (owed > assetCache.totalBorrows) owed = assetCache.totalBorrows;

        assetStorage.users[account].owed = encodeDebtAmount(owedRemaining);
        assetStorage.totalBorrows = assetCache.totalBorrows = encodeDebtAmount(assetCache.totalBorrows - owed + owedRemaining);

        updateInterestRate(assetStorage, assetCache);

        logBorrowChange(assetCache, dTokenAddress, account, prevOwed, owedRemaining);
    }

    function transferBorrow(AssetStorage storage assetStorage, AssetCache memory assetCache, address dTokenAddress, address from, address to, uint origAmount) internal {
        uint amount = origAmount * INTERNAL_DEBT_PRECISION;

        (uint fromOwed, uint fromOwedPrev) = updateUserBorrow(assetStorage, assetCache, from);
        (uint toOwed, uint toOwedPrev) = updateUserBorrow(assetStorage, assetCache, to);

        if (toOwed == 0) doEnterMarket(to, assetCache.underlying);

        // If amount was rounded up, transfer exact amount owed
        if (amount > fromOwed && amount - fromOwed < INTERNAL_DEBT_PRECISION * assetCache.underlyingDecimalsScaler) amount = fromOwed;

        require(fromOwed >= amount, "e/insufficient-balance");
        unchecked { fromOwed -= amount; }

        // Transfer any residual dust
        if (fromOwed < INTERNAL_DEBT_PRECISION) {
            amount += fromOwed;
            fromOwed = 0;
        }

        toOwed += amount;

        assetStorage.users[from].owed = encodeDebtAmount(fromOwed);
        assetStorage.users[to].owed = encodeDebtAmount(toOwed);

        logBorrowChange(assetCache, dTokenAddress, from, fromOwedPrev, fromOwed);
        logBorrowChange(assetCache, dTokenAddress, to, toOwedPrev, toOwed);
    }



    // Reserves

    function increaseReserves(AssetStorage storage assetStorage, AssetCache memory assetCache, uint amount) internal {
        assetStorage.reserveBalance = assetCache.reserveBalance = encodeSmallAmount(assetCache.reserveBalance + amount);
        assetStorage.totalBalances = assetCache.totalBalances = encodeAmount(assetCache.totalBalances + amount);
    }



    // Token asset transfers

    // amounts are in underlying units

    function pullTokens(AssetCache memory assetCache, address from, uint amount) internal returns (uint amountTransferred) {
        uint poolSizeBefore = assetCache.poolSize;

        Utils.safeTransferFrom(assetCache.underlying, from, address(this), amount / assetCache.underlyingDecimalsScaler);
        uint poolSizeAfter = assetCache.poolSize = decodeExternalAmount(assetCache, callBalanceOf(assetCache, address(this)));

        require(poolSizeAfter >= poolSizeBefore, "e/negative-transfer-amount");
        unchecked { amountTransferred = poolSizeAfter - poolSizeBefore; }
    }

    function pushTokens(AssetCache memory assetCache, address to, uint amount) internal returns (uint amountTransferred) {
        uint poolSizeBefore = assetCache.poolSize;

        Utils.safeTransfer(assetCache.underlying, to, amount / assetCache.underlyingDecimalsScaler);
        uint poolSizeAfter = assetCache.poolSize = decodeExternalAmount(assetCache, callBalanceOf(assetCache, address(this)));

        require(poolSizeBefore >= poolSizeAfter, "e/negative-transfer-amount");
        unchecked { amountTransferred = poolSizeBefore - poolSizeAfter; }
    }




    // Liquidity

    function getAssetPrice(address asset) internal returns (uint) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.getPrice.selector, asset));
        return abi.decode(result, (uint));
    }

    function getAccountLiquidity(address account) internal returns (uint collateralValue, uint liabilityValue) {
        bytes memory result = callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.computeLiquidity.selector, account));
        (IRiskManager.LiquidityStatus memory status) = abi.decode(result, (IRiskManager.LiquidityStatus));

        collateralValue = status.collateralValue;
        liabilityValue = status.liabilityValue;
    }

    function checkLiquidity(address account) internal {
        uint8 status = accountLookup[account].deferLiquidityStatus;

        if (status == DEFERLIQUIDITY__NONE) {
            callInternalModule(MODULEID__RISK_MANAGER, abi.encodeWithSelector(IRiskManager.requireLiquidity.selector, account));
        } else if (status == DEFERLIQUIDITY__CLEAN) {
            accountLookup[account].deferLiquidityStatus = DEFERLIQUIDITY__DIRTY;
        }
    }



    // Optional average liquidity tracking

    function computeNewAverageLiquidity(address account, uint deltaT) private returns (uint) {
        uint currDuration = deltaT >= AVERAGE_LIQUIDITY_PERIOD ? AVERAGE_LIQUIDITY_PERIOD : deltaT;
        uint prevDuration = AVERAGE_LIQUIDITY_PERIOD - currDuration;

        uint currAverageLiquidity;

        {
            (uint collateralValue, uint liabilityValue) = getAccountLiquidity(account);
            currAverageLiquidity = collateralValue > liabilityValue ? collateralValue - liabilityValue : 0;
        }

        return (accountLookup[account].averageLiquidity * prevDuration / AVERAGE_LIQUIDITY_PERIOD) +
               (currAverageLiquidity * currDuration / AVERAGE_LIQUIDITY_PERIOD);
    }

    function getUpdatedAverageLiquidity(address account) internal returns (uint) {
        uint lastAverageLiquidityUpdate = accountLookup[account].lastAverageLiquidityUpdate;
        if (lastAverageLiquidityUpdate == 0) return 0;

        uint deltaT = block.timestamp - lastAverageLiquidityUpdate;
        if (deltaT == 0) return accountLookup[account].averageLiquidity;

        return computeNewAverageLiquidity(account, deltaT);
    }

    function getUpdatedAverageLiquidityWithDelegate(address account) internal returns (uint) {
        address delegate = accountLookup[account].averageLiquidityDelegate;

        return delegate != address(0) && accountLookup[delegate].averageLiquidityDelegate == account
            ? getUpdatedAverageLiquidity(delegate)
            : getUpdatedAverageLiquidity(account);
    }

    function updateAverageLiquidity(address account) internal {
        uint lastAverageLiquidityUpdate = accountLookup[account].lastAverageLiquidityUpdate;
        if (lastAverageLiquidityUpdate == 0) return;

        uint deltaT = block.timestamp - lastAverageLiquidityUpdate;
        if (deltaT == 0) return;

        accountLookup[account].lastAverageLiquidityUpdate = uint40(block.timestamp);
        accountLookup[account].averageLiquidity = computeNewAverageLiquidity(account, deltaT);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Storage.sol";

// This interface is used to avoid a circular dependency between BaseLogic and RiskManager

interface IRiskManager {
    struct NewMarketParameters {
        uint16 pricingType;
        uint32 pricingParameters;

        Storage.AssetConfig config;
    }

    struct LiquidityStatus {
        uint collateralValue;
        uint liabilityValue;
        uint numBorrows;
        bool borrowIsolated;
    }

    struct AssetLiquidity {
        address underlying;
        LiquidityStatus status;
    }

    function getNewMarketParameters(address underlying) external returns (NewMarketParameters memory);

    function requireLiquidity(address account) external view;
    function computeLiquidity(address account) external view returns (LiquidityStatus memory status);
    function computeAssetLiquidities(address account) external view returns (AssetLiquidity[] memory assets);

    function getPrice(address underlying) external view returns (uint twap, uint twapPeriod);
    function getPriceFull(address underlying) external view returns (uint twap, uint twapPeriod, uint currPrice);
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Interfaces.sol";
import "./Utils.sol";

/// @notice Protected Tokens are simple wrappers for tokens, allowing you to use tokens as collateral without permitting borrowing
contract PToken {
    address immutable euler;
    address immutable underlyingToken;

    constructor(address euler_, address underlying_) {
        euler = euler_;
        underlyingToken = underlying_;
    }


    mapping(address => uint) balances;
    mapping(address => mapping(address => uint)) allowances;
    uint totalBalances;


    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);


    /// @notice PToken name, ie "Euler Protected DAI"
    function name() external view returns (string memory) {
        return string(abi.encodePacked("Euler Protected ", IERC20(underlyingToken).name()));
    }

    /// @notice PToken symbol, ie "pDAI"
    function symbol() external view returns (string memory) {
        return string(abi.encodePacked("p", IERC20(underlyingToken).symbol()));
    }

    /// @notice Number of decimals, which is same as the underlying's
    function decimals() external view returns (uint8) {
        return IERC20(underlyingToken).decimals();
    }

    /// @notice Address of the underlying asset
    function underlying() external view returns (address) {
        return underlyingToken;
    }


    /// @notice Balance of an account's wrapped tokens
    function balanceOf(address who) external view returns (uint) {
        return balances[who];
    }

    /// @notice Sum of all wrapped token balances
    function totalSupply() external view returns (uint) {
        return totalBalances;
    }

    /// @notice Retrieve the current allowance
    /// @param holder Address giving permission to access tokens
    /// @param spender Trusted address
    function allowance(address holder, address spender) external view returns (uint) {
        return allowances[holder][spender];
    }


    /// @notice Transfer your own pTokens to another address
    /// @param recipient Recipient address
    /// @param amount Amount of wrapped token to transfer
    function transfer(address recipient, uint amount) external returns (bool) {
        return transferFrom(msg.sender, recipient, amount);
    }

    /// @notice Transfer pTokens from one address to another. The euler address is automatically granted approval.
    /// @param from This address must've approved the to address
    /// @param recipient Recipient address
    /// @param amount Amount to transfer
    function transferFrom(address from, address recipient, uint amount) public returns (bool) {
        require(balances[from] >= amount, "insufficient balance");
        if (from != msg.sender && msg.sender != euler && allowances[from][msg.sender] != type(uint).max) {
            require(allowances[from][msg.sender] >= amount, "insufficient allowance");
            allowances[from][msg.sender] -= amount;
            emit Approval(from, msg.sender, allowances[from][msg.sender]);
        }
        balances[from] -= amount;
        balances[recipient] += amount;
        emit Transfer(from, recipient, amount);
        return true;
    }

    /// @notice Allow spender to access an amount of your pTokens. It is not necessary to approve the euler address.
    /// @param spender Trusted address
    /// @param amount Use max uint256 for "infinite" allowance
    function approve(address spender, uint amount) external returns (bool) {
        allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }



    /// @notice Convert underlying tokens to pTokens
    /// @param amount In underlying units (which are equivalent to pToken units)
    function wrap(uint amount) external {
        Utils.safeTransferFrom(underlyingToken, msg.sender, address(this), amount);
        claimSurplus(msg.sender);
    }

    /// @notice Convert pTokens to underlying tokens
    /// @param amount In pToken units (which are equivalent to underlying units)
    function unwrap(uint amount) external {
        doUnwrap(msg.sender, amount);
    }

    // Only callable by the euler contract:
    function forceUnwrap(address who, uint amount) external {
        require(msg.sender == euler, "permission denied");
        doUnwrap(who, amount);
    }

    /// @notice Claim any surplus tokens held by the PToken contract. This should only be used by contracts.
    /// @param who Beneficiary to be credited for the surplus token amount
    function claimSurplus(address who) public {
        uint currBalance = IERC20(underlyingToken).balanceOf(address(this));
        require(currBalance > totalBalances, "no surplus balance to claim");

        uint amount = currBalance - totalBalances;

        totalBalances += amount;
        balances[who] += amount;
        emit Transfer(address(0), who, amount);
    }


    // Internal shared:

    function doUnwrap(address who, uint amount) private {
        require(balances[who] >= amount, "insufficient balance");

        totalBalances -= amount;
        balances[who] -= amount;

        Utils.safeTransfer(underlyingToken, who, amount);
        emit Transfer(who, address(0), amount);
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;


interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}

interface IERC20Permit {
    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
    function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
    function permit(address owner, address spender, uint value, uint deadline, bytes calldata signature) external;
}

interface IERC3156FlashBorrower {
    function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data) external returns (bytes32);
}

interface IERC3156FlashLender {
    function maxFlashLoan(address token) external view returns (uint256);
    function flashFee(address token, uint256 amount) external view returns (uint256);
    function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Interfaces.sol";

library Utils {
    function safeTransferFrom(address token, address from, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }

    function safeTransfer(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }

    function safeApprove(address token, address to, uint value) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), string(data));
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Base.sol";


abstract contract BaseModule is Base {
    // Construction

    // public accessors common to all modules

    uint immutable public moduleId;
    bytes32 immutable public moduleGitCommit;

    constructor(uint moduleId_, bytes32 moduleGitCommit_) {
        moduleId = moduleId_;
        moduleGitCommit = moduleGitCommit_;
    }


    // Accessing parameters

    function unpackTrailingParamMsgSender() internal pure returns (address msgSender) {
        assembly {
            msgSender := shr(96, calldataload(sub(calldatasize(), 40)))
        }
    }

    function unpackTrailingParams() internal pure returns (address msgSender, address proxyAddr) {
        assembly {
            msgSender := shr(96, calldataload(sub(calldatasize(), 40)))
            proxyAddr := shr(96, calldataload(sub(calldatasize(), 20)))
        }
    }


    // Emit logs via proxies

    function emitViaProxy_Transfer(address proxyAddr, address from, address to, uint value) internal FREEMEM {
        (bool success,) = proxyAddr.call(abi.encodePacked(
                               uint8(3),
                               keccak256(bytes('Transfer(address,address,uint256)')),
                               bytes32(uint(uint160(from))),
                               bytes32(uint(uint160(to))),
                               value
                          ));
        require(success, "e/log-proxy-fail");
    }

    function emitViaProxy_Approval(address proxyAddr, address owner, address spender, uint value) internal FREEMEM {
        (bool success,) = proxyAddr.call(abi.encodePacked(
                               uint8(3),
                               keccak256(bytes('Approval(address,address,uint256)')),
                               bytes32(uint(uint160(owner))),
                               bytes32(uint(uint160(spender))),
                               value
                          ));
        require(success, "e/log-proxy-fail");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./BaseModule.sol";

abstract contract BaseIRM is BaseModule {
    constructor(uint moduleId_, bytes32 moduleGitCommit_) BaseModule(moduleId_, moduleGitCommit_) {}

    int96 internal constant MAX_ALLOWED_INTEREST_RATE = int96(int(uint(5 * 1e27) / SECONDS_PER_YEAR)); // 500% APR
    int96 internal constant MIN_ALLOWED_INTEREST_RATE = 0;

    function computeInterestRateImpl(address, uint32) internal virtual returns (int96);

    function computeInterestRate(address underlying, uint32 utilisation) external returns (int96) {
        int96 rate = computeInterestRateImpl(underlying, utilisation);

        if (rate > MAX_ALLOWED_INTEREST_RATE) rate = MAX_ALLOWED_INTEREST_RATE;
        else if (rate < MIN_ALLOWED_INTEREST_RATE) rate = MIN_ALLOWED_INTEREST_RATE;

        return rate;
    }

    function reset(address underlying, bytes calldata resetParams) external virtual {}
}

// SPDX-License-Identifier: AGPL-3.0-or-later

// From MakerDAO DSS

// Copyright (C) 2018 Rain <[email protected]>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

pragma solidity ^0.8.0;

library RPow {
    function rpow(uint x, uint n, uint base) internal pure returns (uint z) {
        assembly {
            switch x case 0 {switch n case 0 {z := base} default {z := 0}}
            default {
                switch mod(n, 2) case 0 { z := base } default { z := x }
                let half := div(base, 2)  // for rounding.
                for { n := div(n, 2) } n { n := div(n,2) } {
                    let xx := mul(x, x)
                    if iszero(eq(div(xx, x), x)) { revert(0,0) }
                    let xxRound := add(xx, half)
                    if lt(xxRound, xx) { revert(0,0) }
                    x := div(xxRound, base)
                    if mod(n,2) {
                        let zx := mul(z, x)
                        if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) }
                        let zxRound := add(zx, half)
                        if lt(zxRound, zx) { revert(0,0) }
                        z := div(zxRound, base)
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;
//import "hardhat/console.sol"; // DEV_MODE

import "./Storage.sol";
import "./Events.sol";
import "./Proxy.sol";

abstract contract Base is Storage, Events {
    // Modules

    function _createProxy(uint proxyModuleId) internal returns (address) {
        require(proxyModuleId != 0, "e/create-proxy/invalid-module");
        require(proxyModuleId <= MAX_EXTERNAL_MODULEID, "e/create-proxy/internal-module");

        // If we've already created a proxy for a single-proxy module, just return it:

        if (proxyLookup[proxyModuleId] != address(0)) return proxyLookup[proxyModuleId];

        // Otherwise create a proxy:

        address proxyAddr = address(new Proxy());

        if (proxyModuleId <= MAX_EXTERNAL_SINGLE_PROXY_MODULEID) proxyLookup[proxyModuleId] = proxyAddr;

        trustedSenders[proxyAddr] = TrustedSenderInfo({ moduleId: uint32(proxyModuleId), moduleImpl: address(0) });

        emit ProxyCreated(proxyAddr, proxyModuleId);

        return proxyAddr;
    }

    function callInternalModule(uint moduleId, bytes memory input) internal returns (bytes memory) {
        (bool success, bytes memory result) = moduleLookup[moduleId].delegatecall(input);
        if (!success) revertBytes(result);
        return result;
    }



    // Modifiers

    modifier nonReentrant() {
        require(reentrancyLock == REENTRANCYLOCK__UNLOCKED, "e/reentrancy");

        reentrancyLock = REENTRANCYLOCK__LOCKED;
        _;
        reentrancyLock = REENTRANCYLOCK__UNLOCKED;
    }

    modifier reentrantOK() { // documentation only
        _;
    }

    // Used to flag functions which do not modify storage, but do perform a delegate call
    // to a view function, which prohibits a standard view modifier. The flag is used to
    // patch state mutability in compiled ABIs and interfaces.
    modifier staticDelegate() {
        _;
    }

    // WARNING: Must be very careful with this modifier. It resets the free memory pointer
    // to the value it was when the function started. This saves gas if more memory will
    // be allocated in the future. However, if the memory will be later referenced
    // (for example because the function has returned a pointer to it) then you cannot
    // use this modifier.

    modifier FREEMEM() {
        uint origFreeMemPtr;

        assembly {
            origFreeMemPtr := mload(0x40)
        }

        _;

        /*
        assembly { // DEV_MODE: overwrite the freed memory with garbage to detect bugs
            let garbage := 0xDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF
            for { let i := origFreeMemPtr } lt(i, mload(0x40)) { i := add(i, 32) } { mstore(i, garbage) }
        }
        */

        assembly {
            mstore(0x40, origFreeMemPtr)
        }
    }



    // Error handling

    function revertBytes(bytes memory errMsg) internal pure {
        if (errMsg.length > 0) {
            assembly {
                revert(add(32, errMsg), mload(errMsg))
            }
        }

        revert("e/empty-error");
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Constants.sol";

abstract contract Storage is Constants {
    // Dispatcher and upgrades

    uint internal reentrancyLock;

    address upgradeAdmin;
    address governorAdmin;

    mapping(uint => address) moduleLookup; // moduleId => module implementation
    mapping(uint => address) proxyLookup; // moduleId => proxy address (only for single-proxy modules)

    struct TrustedSenderInfo {
        uint32 moduleId; // 0 = un-trusted
        address moduleImpl; // only non-zero for external single-proxy modules
    }

    mapping(address => TrustedSenderInfo) trustedSenders; // sender address => moduleId (0 = un-trusted)



    // Account-level state
    // Sub-accounts are considered distinct accounts

    struct AccountStorage {
        // Packed slot: 1 + 5 + 4 + 20 = 30
        uint8 deferLiquidityStatus;
        uint40 lastAverageLiquidityUpdate;
        uint32 numMarketsEntered;
        address firstMarketEntered;

        uint averageLiquidity;
        address averageLiquidityDelegate;
    }

    mapping(address => AccountStorage) accountLookup;
    mapping(address => address[MAX_POSSIBLE_ENTERED_MARKETS]) marketsEntered;



    // Markets and assets

    struct AssetConfig {
        // Packed slot: 20 + 1 + 4 + 4 + 3 = 32
        address eTokenAddress;
        bool borrowIsolated;
        uint32 collateralFactor;
        uint32 borrowFactor;
        uint24 twapWindow;
    }

    struct UserAsset {
        uint112 balance;
        uint144 owed;

        uint interestAccumulator;
    }

    struct AssetStorage {
        // Packed slot: 5 + 1 + 4 + 12 + 4 + 2 + 4 = 32
        uint40 lastInterestAccumulatorUpdate;
        uint8 underlyingDecimals; // Not dynamic, but put here to live in same storage slot
        uint32 interestRateModel;
        int96 interestRate;
        uint32 reserveFee;
        uint16 pricingType;
        uint32 pricingParameters;

        address underlying;
        uint96 reserveBalance;

        address dTokenAddress;

        uint112 totalBalances;
        uint144 totalBorrows;

        uint interestAccumulator;

        mapping(address => UserAsset) users;

        mapping(address => mapping(address => uint)) eTokenAllowance;
        mapping(address => mapping(address => uint)) dTokenAllowance;
    }

    mapping(address => AssetConfig) internal underlyingLookup; // underlying => AssetConfig
    mapping(address => AssetStorage) internal eTokenLookup; // EToken => AssetStorage
    mapping(address => address) internal dTokenLookup; // DToken => EToken
    mapping(address => address) internal pTokenLookup; // PToken => underlying
    mapping(address => address) internal reversePTokenLookup; // underlying => PToken
    mapping(address => address) internal chainlinkPriceFeedLookup; // underlying => chainlinkAggregator
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

import "./Storage.sol";

abstract contract Events {
    event Genesis();


    event ProxyCreated(address indexed proxy, uint moduleId);
    event MarketActivated(address indexed underlying, address indexed eToken, address indexed dToken);
    event PTokenActivated(address indexed underlying, address indexed pToken);

    event EnterMarket(address indexed underlying, address indexed account);
    event ExitMarket(address indexed underlying, address indexed account);

    event Deposit(address indexed underlying, address indexed account, uint amount);
    event Withdraw(address indexed underlying, address indexed account, uint amount);
    event Borrow(address indexed underlying, address indexed account, uint amount);
    event Repay(address indexed underlying, address indexed account, uint amount);

    event Liquidation(address indexed liquidator, address indexed violator, address indexed underlying, address collateral, uint repay, uint yield, uint healthScore, uint baseDiscount, uint discount);

    event TrackAverageLiquidity(address indexed account);
    event UnTrackAverageLiquidity(address indexed account);
    event DelegateAverageLiquidity(address indexed account, address indexed delegate);

    event PTokenWrap(address indexed underlying, address indexed account, uint amount);
    event PTokenUnWrap(address indexed underlying, address indexed account, uint amount);

    event AssetStatus(address indexed underlying, uint totalBalances, uint totalBorrows, uint96 reserveBalance, uint poolSize, uint interestAccumulator, int96 interestRate, uint timestamp);


    event RequestDeposit(address indexed account, uint amount);
    event RequestWithdraw(address indexed account, uint amount);
    event RequestMint(address indexed account, uint amount);
    event RequestBurn(address indexed account, uint amount);
    event RequestTransferEToken(address indexed from, address indexed to, uint amount);
    event RequestDonate(address indexed account, uint amount);

    event RequestBorrow(address indexed account, uint amount);
    event RequestRepay(address indexed account, uint amount);
    event RequestTransferDToken(address indexed from, address indexed to, uint amount);

    event RequestLiquidate(address indexed liquidator, address indexed violator, address indexed underlying, address collateral, uint repay, uint minYield);


    event InstallerSetUpgradeAdmin(address indexed newUpgradeAdmin);
    event InstallerSetGovernorAdmin(address indexed newGovernorAdmin);
    event InstallerInstallModule(uint indexed moduleId, address indexed moduleImpl, bytes32 moduleGitCommit);


    event GovSetAssetConfig(address indexed underlying, Storage.AssetConfig newConfig);
    event GovSetIRM(address indexed underlying, uint interestRateModel, bytes resetParams);
    event GovSetPricingConfig(address indexed underlying, uint16 newPricingType, uint32 newPricingParameter);
    event GovSetReserveFee(address indexed underlying, uint32 newReserveFee);
    event GovConvertReserves(address indexed underlying, address indexed recipient, uint amount);
    event GovSetChainlinkPriceFeed(address indexed underlying, address chainlinkAggregator);

    event RequestSwap(address indexed accountIn, address indexed accountOut, address indexed underlyingIn, address underlyingOut, uint amount, uint swapType);
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

contract Proxy {
    address immutable creator;

    constructor() {
        creator = msg.sender;
    }

    // External interface

    fallback() external {
        address creator_ = creator;

        if (msg.sender == creator_) {
            assembly {
                mstore(0, 0)
                calldatacopy(31, 0, calldatasize())

                switch mload(0) // numTopics
                    case 0 { log0(32,  sub(calldatasize(), 1)) }
                    case 1 { log1(64,  sub(calldatasize(), 33),  mload(32)) }
                    case 2 { log2(96,  sub(calldatasize(), 65),  mload(32), mload(64)) }
                    case 3 { log3(128, sub(calldatasize(), 97),  mload(32), mload(64), mload(96)) }
                    case 4 { log4(160, sub(calldatasize(), 129), mload(32), mload(64), mload(96), mload(128)) }
                    default { revert(0, 0) }

                return(0, 0)
            }
        } else {
            assembly {
                mstore(0, 0xe9c4a3ac00000000000000000000000000000000000000000000000000000000) // dispatch() selector
                calldatacopy(4, 0, calldatasize())
                mstore(add(4, calldatasize()), shl(96, caller()))

                let result := call(gas(), creator_, 0, 0, add(24, calldatasize()), 0, 0)
                returndatacopy(0, 0, returndatasize())

                switch result
                    case 0 { revert(0, returndatasize()) }
                    default { return(0, returndatasize()) }
            }
        }
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later

pragma solidity ^0.8.0;

abstract contract Constants {
    // Universal

    uint internal constant SECONDS_PER_YEAR = 365.2425 * 86400; // Gregorian calendar


    // Protocol parameters

    uint internal constant MAX_SANE_AMOUNT = type(uint112).max;
    uint internal constant MAX_SANE_SMALL_AMOUNT = type(uint96).max;
    uint internal constant MAX_SANE_DEBT_AMOUNT = type(uint144).max;
    uint internal constant INTERNAL_DEBT_PRECISION = 1e9;
    uint internal constant MAX_ENTERED_MARKETS = 10; // per sub-account
    uint internal constant MAX_POSSIBLE_ENTERED_MARKETS = 2**32; // limited by size of AccountStorage.numMarketsEntered
    uint internal constant CONFIG_FACTOR_SCALE = 4_000_000_000; // must fit into a uint32
    uint internal constant RESERVE_FEE_SCALE = 4_000_000_000; // must fit into a uint32
    uint32 internal constant DEFAULT_RESERVE_FEE = uint32(0.23 * 4_000_000_000);
    uint internal constant INITIAL_RESERVES = 1e6;
    uint internal constant INITIAL_INTEREST_ACCUMULATOR = 1e27;
    uint internal constant AVERAGE_LIQUIDITY_PERIOD = 24 * 60 * 60;
    uint16 internal constant MIN_UNISWAP3_OBSERVATION_CARDINALITY = 144;
    uint24 internal constant DEFAULT_TWAP_WINDOW_SECONDS = 30 * 60;
    uint32 internal constant DEFAULT_BORROW_FACTOR = uint32(0.28 * 4_000_000_000);
    uint32 internal constant SELF_COLLATERAL_FACTOR = uint32(0.95 * 4_000_000_000);


    // Implementation internals

    uint internal constant REENTRANCYLOCK__UNLOCKED = 1;
    uint internal constant REENTRANCYLOCK__LOCKED = 2;

    uint8 internal constant DEFERLIQUIDITY__NONE = 0;
    uint8 internal constant DEFERLIQUIDITY__CLEAN = 1;
    uint8 internal constant DEFERLIQUIDITY__DIRTY = 2;


    // Pricing types

    uint16 internal constant PRICINGTYPE__PEGGED = 1;
    uint16 internal constant PRICINGTYPE__UNISWAP3_TWAP = 2;
    uint16 internal constant PRICINGTYPE__FORWARDED = 3;
    uint16 internal constant PRICINGTYPE__CHAINLINK = 4;

    // Correct pricing types are always less than this value
    uint16 internal constant PRICINGTYPE__OUT_OF_BOUNDS = 5;


    // Modules

    // Public single-proxy modules
    uint internal constant MODULEID__INSTALLER = 1;
    uint internal constant MODULEID__MARKETS = 2;
    uint internal constant MODULEID__LIQUIDATION = 3;
    uint internal constant MODULEID__GOVERNANCE = 4;
    uint internal constant MODULEID__EXEC = 5;
    uint internal constant MODULEID__SWAP = 6;

    uint internal constant MAX_EXTERNAL_SINGLE_PROXY_MODULEID = 499_999;

    // Public multi-proxy modules
    uint internal constant MODULEID__ETOKEN = 500_000;
    uint internal constant MODULEID__DTOKEN = 500_001;

    uint internal constant MAX_EXTERNAL_MODULEID = 999_999;

    // Internal modules
    uint internal constant MODULEID__RISK_MANAGER = 1_000_000;

    // Interest rate models
    //   Default for new markets
    uint internal constant MODULEID__IRM_DEFAULT = 2_000_000;
    //   Testing-only
    uint internal constant MODULEID__IRM_ZERO = 2_000_001;
    uint internal constant MODULEID__IRM_FIXED = 2_000_002;
    uint internal constant MODULEID__IRM_LINEAR = 2_000_100;
    //   Classes
    uint internal constant MODULEID__IRM_CLASS__STABLE = 2_000_500;
    uint internal constant MODULEID__IRM_CLASS__MAJOR = 2_000_501;
    uint internal constant MODULEID__IRM_CLASS__MIDCAP = 2_000_502;
    uint internal constant MODULEID__IRM_CLASS__MEGA = 2_000_503;

    // Swap types
    uint internal constant SWAP_TYPE__UNI_EXACT_INPUT_SINGLE = 1;
    uint internal constant SWAP_TYPE__UNI_EXACT_INPUT = 2;
    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT_SINGLE = 3;
    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT = 4;
    uint internal constant SWAP_TYPE__1INCH = 5;

    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT_SINGLE_REPAY = 6;
    uint internal constant SWAP_TYPE__UNI_EXACT_OUTPUT_REPAY = 7;
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"moduleGitCommit_","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"result","type":"bytes"}],"internalType":"struct Exec.EulerBatchItemResponse[]","name":"simulation","type":"tuple[]"}],"name":"BatchDispatchSimulation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalBalances","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"},{"indexed":false,"internalType":"uint96","name":"reserveBalance","type":"uint96"},{"indexed":false,"internalType":"uint256","name":"poolSize","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interestAccumulator","type":"uint256"},{"indexed":false,"internalType":"int96","name":"interestRate","type":"int96"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"AssetStatus","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Borrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"delegate","type":"address"}],"name":"DelegateAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"EnterMarket","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ExitMarket","type":"event"},{"anonymous":false,"inputs":[],"name":"Genesis","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"GovConvertReserves","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"components":[{"internalType":"address","name":"eTokenAddress","type":"address"},{"internalType":"bool","name":"borrowIsolated","type":"bool"},{"internalType":"uint32","name":"collateralFactor","type":"uint32"},{"internalType":"uint32","name":"borrowFactor","type":"uint32"},{"internalType":"uint24","name":"twapWindow","type":"uint24"}],"indexed":false,"internalType":"struct Storage.AssetConfig","name":"newConfig","type":"tuple"}],"name":"GovSetAssetConfig","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"address","name":"chainlinkAggregator","type":"address"}],"name":"GovSetChainlinkPriceFeed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint256","name":"interestRateModel","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"resetParams","type":"bytes"}],"name":"GovSetIRM","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint16","name":"newPricingType","type":"uint16"},{"indexed":false,"internalType":"uint32","name":"newPricingParameter","type":"uint32"}],"name":"GovSetPricingConfig","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"uint32","name":"newReserveFee","type":"uint32"}],"name":"GovSetReserveFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"moduleId","type":"uint256"},{"indexed":true,"internalType":"address","name":"moduleImpl","type":"address"},{"indexed":false,"internalType":"bytes32","name":"moduleGitCommit","type":"bytes32"}],"name":"InstallerInstallModule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newGovernorAdmin","type":"address"}],"name":"InstallerSetGovernorAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newUpgradeAdmin","type":"address"}],"name":"InstallerSetUpgradeAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"violator","type":"address"},{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"repay","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"yield","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"healthScore","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"baseDiscount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"discount","type":"uint256"}],"name":"Liquidation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"eToken","type":"address"},{"indexed":true,"internalType":"address","name":"dToken","type":"address"}],"name":"MarketActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"pToken","type":"address"}],"name":"PTokenActivated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PTokenUnWrap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PTokenWrap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"proxy","type":"address"},{"indexed":false,"internalType":"uint256","name":"moduleId","type":"uint256"}],"name":"ProxyCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Repay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestBorrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestDonate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":true,"internalType":"address","name":"violator","type":"address"},{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":false,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"uint256","name":"repay","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minYield","type":"uint256"}],"name":"RequestLiquidate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestRepay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"accountIn","type":"address"},{"indexed":true,"internalType":"address","name":"accountOut","type":"address"},{"indexed":true,"internalType":"address","name":"underlyingIn","type":"address"},{"indexed":false,"internalType":"address","name":"underlyingOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"swapType","type":"uint256"}],"name":"RequestSwap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestTransferDToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestTransferEToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RequestWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"TrackAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"UnTrackAverageLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"underlying","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"components":[{"internalType":"bool","name":"allowError","type":"bool"},{"internalType":"address","name":"proxyAddr","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Exec.EulerBatchItem[]","name":"items","type":"tuple[]"},{"internalType":"address[]","name":"deferLiquidityChecks","type":"address[]"}],"name":"batchDispatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bool","name":"allowError","type":"bool"},{"internalType":"address","name":"proxyAddr","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct Exec.EulerBatchItem[]","name":"items","type":"tuple[]"},{"internalType":"address[]","name":"deferLiquidityChecks","type":"address[]"}],"name":"batchDispatchSimulate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"deferLiquidityCheck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"detailedLiquidity","outputs":[{"components":[{"internalType":"address","name":"underlying","type":"address"},{"components":[{"internalType":"uint256","name":"collateralValue","type":"uint256"},{"internalType":"uint256","name":"liabilityValue","type":"uint256"},{"internalType":"uint256","name":"numBorrows","type":"uint256"},{"internalType":"bool","name":"borrowIsolated","type":"bool"}],"internalType":"struct IRiskManager.LiquidityStatus","name":"status","type":"tuple"}],"internalType":"struct IRiskManager.AssetLiquidity[]","name":"assets","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"doStaticCall","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAverageLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAverageLiquidityDelegateAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAverageLiquidityWithDelegate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"underlying","type":"address"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"twap","type":"uint256"},{"internalType":"uint256","name":"twapPeriod","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"underlying","type":"address"}],"name":"getPriceFull","outputs":[{"internalType":"uint256","name":"twap","type":"uint256"},{"internalType":"uint256","name":"twapPeriod","type":"uint256"},{"internalType":"uint256","name":"currPrice","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"liquidity","outputs":[{"components":[{"internalType":"uint256","name":"collateralValue","type":"uint256"},{"internalType":"uint256","name":"liabilityValue","type":"uint256"},{"internalType":"uint256","name":"numBorrows","type":"uint256"},{"internalType":"bool","name":"borrowIsolated","type":"bool"}],"internalType":"struct IRiskManager.LiquidityStatus","name":"status","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"moduleGitCommit","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"moduleId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"underlying","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"pTokenUnWrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"underlying","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"pTokenWrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"subAccountId","type":"uint256"},{"internalType":"address","name":"delegate","type":"address"},{"internalType":"bool","name":"onlyDelegate","type":"bool"}],"name":"trackAverageLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"subAccountId","type":"uint256"}],"name":"unTrackAverageLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"usePermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"bool","name":"allowed","type":"bool"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"usePermitAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"usePermitPacked","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d7f62927eb58592d82302c87205490c26cccca7c

-----Decoded View---------------
Arg [0] : moduleGitCommit_ (bytes32): 0x000000000000000000000000d7f62927eb58592d82302c87205490c26cccca7c

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d7f62927eb58592d82302c87205490c26cccca7c

518:15294:12:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5568:247;;;;;;:::i;:::-;;:::i;:::-;;11854:403;;;;;;:::i;:::-;;:::i;9397:722::-;;;;;;:::i;:::-;;:::i;2543:361::-;;;;;;:::i;:::-;;:::i;:::-;;;;3189:25:14;;;3245:2;3230:18;;3223:34;;;;3162:18;2543:361:12;;;;;;;;13306:320;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8446:166::-;;;;;;:::i;:::-;;:::i;:::-;;;5972:25:14;;;5960:2;5945:18;8446:166:12;5826:177:14;241:40:3;;;;;6458:664:12;;;;;;:::i;:::-;;:::i;4185:631::-;;;;;;:::i;:::-;;:::i;3354:402::-;;;;;;:::i;:::-;;:::i;:::-;;;;6847:25:14;;;6903:2;6888:18;;6881:34;;;;6931:18;;;6924:34;6835:2;6820:18;3354:402:12;6645:319:14;205:30:3;;;;;11050:377:12;;;;;;:::i;:::-;;:::i;1258:388::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;12540:380::-;;;;;;:::i;:::-;;:::i;7296:502::-;;;;;;:::i;:::-;;:::i;10319:396::-;;;;;;:::i;:::-;;:::i;1862:403::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8840:276::-;;;;;;:::i;:::-;;:::i;:::-;;;10269:42:14;10257:55;;;10239:74;;10227:2;10212:18;8840:276:12;10093:226:14;8036:142:12;;;;;;:::i;:::-;;:::i;5028:186::-;;;;;;:::i;:::-;;:::i;5568:247::-;5704:50:::1;5720:5;;5727:20;;5749:4;5704:15;:50::i;:::-;5765:43;::::0;::::1;::::0;;10526:2:14;5765:43:12::1;::::0;::::1;10508:21:14::0;10565:2;10545:18;;;10538:30;10604:34;10584:18;;;10577:62;10675:3;10655:18;;;10648:31;10696:19;;5765:43:12::1;;;;;;;;11854:403:::0;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;;;12011:51:12::1;:23:::0;;::::1;::::0;;:16:::1;:23;::::0;;;;;:37;::::1;12003:91;;;::::0;::::1;::::0;;11269:2:14;12003:91:12::1;::::0;::::1;11251:21:14::0;11308:2;11288:18;;;11281:30;11347:29;11327:18;;;11320:57;11394:18;;12003:91:12::1;11067:351:14::0;12003:91:12::1;12104:17;612:14:3::0;608:23;;595:37;591:2;587:46;12165:85:12::1;::::0;;;;:26:::1;11835:15:14::0;;;12165:85:12::1;::::0;::::1;11817:34:14::0;12211:4:12::1;11867:18:14::0;;;11860:43;11919:18;;;11912:34;;;11962:18;;;11955:34;;;12033:14;;12026:22;12005:19;;;11998:51;12098:4;12086:17;;12065:19;;;12058:46;12120:19;;;12113:35;;;12164:19;;;12157:35;;;12104:50:12;;-1:-1:-1;12165:26:12;;::::1;::::0;::::1;::::0;11728:19:14;;12165:85:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1526:1:4;1519:14:0;:41;-1:-1:-1;;;;;;;;;;11854:403:12:o;9397:722::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;9548:41:12::1;::::0;5972:25:14;;;608:23:3;612:14;608:23;595:37;591:2;587:46;;;;9548:41:12::1;::::0;::::1;::::0;::::1;::::0;5960:2:14;5945:18;9548:41:12::1;;;;;;;9621:31;::::0;;::::1;9600:18;9621:31:::0;;;:19:::1;:31;::::0;;;;;::::1;9670:24:::0;9662:60:::1;;;::::0;::::1;::::0;;12405:2:14;9662:60:12::1;::::0;::::1;12387:21:14::0;12444:2;12424:18;;;12417:30;12483:25;12463:18;;;12456:53;12526:18;;9662:60:12::1;12203:347:14::0;9662:60:12::1;9766:40;::::0;;;;:28:::1;10257:55:14::0;;;9766:40:12::1;::::0;::::1;10239:74:14::0;9747:16:12::1;::::0;9766:28;;::::1;::::0;::::1;::::0;10212:18:14;;9766:40:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9747:59;;9820:65;9843:10;9855:9;9866:10;9878:6;9820:22;:65::i;:::-;9917:40;::::0;;;;:28:::1;10257:55:14::0;;;9917:40:12::1;::::0;::::1;10239:74:14::0;9899:15:12::1;::::0;9917:28;;::::1;::::0;::::1;::::0;10212:18:14;;9917:40:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9899:58:::0;-1:-1:-1;9993:20:12::1;10007:6:::0;9993:11;:20:::1;:::i;:::-;9979:10;:34;9971:78;;;::::0;::::1;::::0;;13268:2:14;9971:78:12::1;::::0;::::1;13250:21:14::0;13307:2;13287:18;;;13280:30;13346:33;13326:18;;;13319:61;13397:18;;9971:78:12::1;13066:355:14::0;9971:78:12::1;-1:-1:-1::0;;10070:42:12::1;::::0;;;;:31:::1;10257:55:14::0;;;10070:42:12::1;::::0;::::1;10239:74:14::0;10070:31:12;::::1;::::0;::::1;::::0;10212:18:14;;10070:42:12::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1526:1:4;1519:14:0;:41;-1:-1:-1;;;;;;9397:722:12:o;2543:361::-;2766:66:::1;::::0;10269:42:14;10257:55;;2766:66:12::1;::::0;::::1;10239:74:14::0;2614:9:12;;;;;;2674:159:::1;::::0;2838:9:4::1;::::0;2789:30:12;;10212:18:14;;2766:66:12::1;;::::0;;;;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;;2674:18:::1;:159::i;:::-;2652:181;;2876:6;2865:32;;;;;;;;;;;;:::i;:::-;2844:53:::0;;;;-1:-1:-1;2543:361:12;-1:-1:-1;;;2543:361:12:o;13306:320::-;13398:12;13423;13437:19;13460:15;:26;;13487:7;13460:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13422:73;;;;13510:7;13505:33;;13519:19;13531:6;13519:11;:19::i;:::-;13602:6;13596:13;13587:6;13583:2;13579:15;13572:38;8446:166;8535:4;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;8558:47:12::1;8597:7:::0;8558:38:::1;:47::i;:::-;1526:1:4::0;1519:14:0;:41;8551:54:12;8446:166;-1:-1:-1;;8446:166:12:o;6458:664::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;;;608:23:3;612:14;608:23;595:37;591:2;587:46;;6655:38:12::1;587:46:3::0;6680:12:12;6655:13:::1;:38::i;:::-;6637:56;;6722:8;6711:19;;:7;:19;;;;6703:65;;;::::0;::::1;::::0;;14157:2:14;6703:65:12::1;::::0;::::1;14139:21:14::0;14196:2;14176:18;;;14169:30;14235:34;14215:18;;;14208:62;14306:3;14286:18;;;14279:31;14327:19;;6703:65:12::1;13955:397:14::0;6703:65:12::1;6818:8;6784:43;;6809:7;6784:43;;;;;;;;;;;;6837:22;::::0;;::::1;;::::0;;;:13:::1;:22;::::0;;;;:47:::1;;:58:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;6906:25;::::1;;;6924:7;;;;6906:25;6946:30;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;6987:22;;;::::0;;;:13:::1;:22;::::0;;;;:75;;;::::1;;7046:15;6987:75;;;;::::0;;-1:-1:-1;7072:39:12::1;:43:::0;-1:-1:-1;1508:1:0::1;-1:-1:-1::0;;1526:1:4;1519:14:0;:41;-1:-1:-1;6458:664:12:o;4185:631::-;4350:22:::1;::::0;::::1;4281:17;4350:22:::0;;;:13:::1;:22;::::0;;;;:43;608:23:3;612:14;608:23;595:37;591:2;587:46;;4350:67:12::1;:43;:67:::0;4342:98:::1;;;::::0;::::1;::::0;;14559:2:14;4342:98:12::1;::::0;::::1;14541:21:14::0;14598:2;14578:18;;;14571:30;14637:20;14617:18;;;14610:48;14675:18;;4342:98:12::1;14357:342:14::0;4342:98:12::1;4450:22;::::0;;::::1;;::::0;;;:13:::1;:22;::::0;;;;;;:67;;;::::1;1691:1:4;4450:67:12;::::0;;4528:65;;;;:59;;::::1;::::0;::::1;::::0;:65:::1;::::0;4588:4;;4528:65:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;;;4619:22:12::1;::::0;::::1;4604:12;4619:22:::0;;;:13:::1;:22;::::0;;;;:43;;4672:66;;::::1;::::0;;;4619:43:::1;;1746:1:4;4753:31:12::0;::::1;4749:60;;;4786:23;4801:7;4786:14;:23::i;:::-;4271:545;;4185:631:::0;;:::o;3354:402::-;3597:70:::1;::::0;10269:42:14;10257:55;;3597:70:12::1;::::0;::::1;10239:74:14::0;3429:9:12;;;;;;;;3505:163:::1;::::0;2838:9:4::1;::::0;3620:34:12;;10212:18:14;;3597:70:12::1;10093:226:14::0;3505:163:12::1;3483:185;;3722:6;3711:38;;;;;;;;;;;;:::i;:::-;3679:70:::0;;;;-1:-1:-1;3679:70:12;;-1:-1:-1;3354:402:12;-1:-1:-1;;;3354:402:12:o;11050:377::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;;;11188:51:12::1;:23:::0;;::::1;::::0;;:16:::1;:23;::::0;;;;;:37;::::1;11180:91;;;::::0;::::1;::::0;;11269:2:14;11180:91:12::1;::::0;::::1;11251:21:14::0;11308:2;11288:18;;;11281:30;11347:29;11327:18;;;11320:57;11394:18;;11180:91:12::1;11067:351:14::0;11180:91:12::1;11281:17;612:14:3::0;608:23;;595:37;591:2;587:46;11342:78:12::1;::::0;;;;:26:::1;15405:15:14::0;;;11342:78:12::1;::::0;::::1;15387:34:14::0;11388:4:12::1;15437:18:14::0;;;15430:43;15489:18;;;15482:34;;;15532:18;;;15525:34;;;15608:4;15596:17;;15575:19;;;15568:46;15630:19;;;15623:35;;;15674:19;;;15667:35;;;11281:50:12;;-1:-1:-1;11342:26:12;;::::1;::::0;::::1;::::0;15298:19:14;;11342:78:12::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1526:1:4;1519:14:0;:41;-1:-1:-1;;;;;;;;;11050:377:12:o;1258:388::-;1327:42;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1327:42:12;1495:71:::1;::::0;10269:42:14;10257:55;;1495:71:12::1;::::0;::::1;10239:74:14::0;1381:19:12::1;::::0;1403:164:::1;::::0;2838:9:4::1;::::0;1518:38:12;;10212:18:14;;1495:71:12::1;10093:226:14::0;1403:164:12::1;1381:186;;1600:6;1589:50;;;;;;;;;;;;:::i;:::-;1578:61:::0;1258:388;-1:-1:-1;;;1258:388:12:o;12540:380::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;;;12679:51:12::1;:23:::0;;::::1;::::0;;:16:::1;:23;::::0;;;;;:37;::::1;12671:91;;;::::0;::::1;::::0;;11269:2:14;12671:91:12::1;::::0;::::1;11251:21:14::0;11308:2;11288:18;;;11281:30;11347:29;11327:18;;;11320:57;11394:18;;12671:91:12::1;11067:351:14::0;12671:91:12::1;12833:80;::::0;;;;608:23:3;612:14;608:23;595:37;591:2;587:46;;12833:26:12::1;::::0;::::1;::::0;::::1;::::0;:80:::1;::::0;587:46:3;;12879:4:12::1;::::0;12886:5;;12893:8;;12903:9;;;;12833:80:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;1526:1:4;1519:14:0;:41;-1:-1:-1;;;;;;;;12540:380:12:o;7296:502::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;;;608:23:3;612:14;608:23;595:37;591:2;587:46;;7458:38:12::1;587:46:3::0;7483:12:12;7458:13:::1;:38::i;:::-;7512:32;::::0;7440:56;;-1:-1:-1;7512:32:12::1;::::0;::::1;::::0;::::1;::::0;;;::::1;7559:45;::::0;7601:1:::1;::::0;7559:45:::1;::::0;::::1;::::0;::::1;::::0;7601:1;;7559:45:::1;7615:22;;7667:1;7615:22:::0;;;:13:::1;:22;::::0;;;;:53;;;::::1;::::0;;:49:::1;7678:39:::0;;::::1;:43:::0;;;7731:47:::1;::::0;;::::1;:60:::0;;;::::1;::::0;;1519:41:0;;-1:-1:-1;;7296:502:12:o;10319:396::-;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;10472:43:12::1;::::0;5972:25:14;;;608:23:3;612:14;608:23;595:37;591:2;587:46;;;;10472:43:12::1;::::0;::::1;::::0;::::1;::::0;5960:2:14;5945:18;10472:43:12::1;;;;;;;10547:31;::::0;;::::1;10526:18;10547:31:::0;;;:19:::1;:31;::::0;;;;;::::1;10596:24:::0;10588:60:::1;;;::::0;::::1;::::0;;12405:2:14;10588:60:12::1;::::0;::::1;12387:21:14::0;12444:2;12424:18;;;12417:30;12483:25;12463:18;;;12456:53;12526:18;;10588:60:12::1;12203:347:14::0;10588:60:12::1;10659:49;::::0;;;;:30:::1;17667:55:14::0;;;10659:49:12::1;::::0;::::1;17649:74:14::0;17739:18;;;17732:34;;;10659:30:12;::::1;::::0;::::1;::::0;17622:18:14;;10659:49:12::1;17475:297:14::0;1862:403:12;2106:78:::1;::::0;10269:42:14;10257:55;;2106:78:12::1;::::0;::::1;10239:74:14::0;1937:43:12;;1992:19:::1;::::0;2014:171:::1;::::0;2838:9:4::1;::::0;2129:45:12;;10212:18:14;;2106:78:12::1;10093:226:14::0;2014:171:12::1;1992:193;;2218:6;2207:51;;;;;;;;;;;;:::i;8840:276::-:0;8962:22;;;;8924:7;8962:22;;;:13;:22;;;;;;:47;;;;;;;9026:23;;;;;;:48;;8924:7;;8962:47;;9026:48;;:59;:83;;9107:1;9026:83;;;9088:8;9019:90;-1:-1:-1;;8840:276:12:o;8036:142::-;8113:4;1526:1:4;1389:14:0;;:42;1381:67;;;;;;;10928:2:14;1381:67:0;;;10910:21:14;10967:2;10947:18;;;10940:30;11006:14;10986:18;;;10979:42;11038:18;;1381:67:0;10726:336:14;1381:67:0;1581:1:4;1459:14:0;:39;8136:35:12::1;8163:7:::0;8136:26:::1;:35::i;5028:186::-:0;5156:51:::1;5172:5;;5179:20;;5201:5;13632:2178:::0;608:23:3;612:14;608:23;595:37;591:2;587:46;13770:17:12;13831:315;13848:31;;;13831:315;;;13900:15;13918:20;;13939:1;13918:23;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;13964:22;;;1636:1:4;13964:22:12;;;:13;:22;;;;;:43;13900:41;;-1:-1:-1;13964:67:12;:43;:67;13956:98;;;;;;;19547:2:14;13956:98:12;;;19529:21:14;19586:2;19566:18;;;19559:30;19625:20;19605:18;;;19598:48;19663:18;;13956:98:12;19345:342:14;13956:98:12;14068:22;;;;;;:13;:22;;;;;:67;;;;1691:1:4;14068:67:12;;;13881:3;;;:::i;:::-;;;13831:315;;;;14157:40;14211:14;14207:73;;;14267:5;14238:42;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;14238:42:12;;;;;;;;;;;;;;;;14227:53;;14207:73;14296:6;14291:1083;14308:16;;;14291:1083;;;14345:28;14376:5;;14382:1;14376:8;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;14345:39;-1:-1:-1;14398:17:12;14418:14;;;;;;;;:::i;:::-;14465:25;;;;14447:15;14465:25;;;:14;:25;;;;;:34;14398;;-1:-1:-1;14465:34:12;;;;14534:36;;;;14593:13;14585:52;;;;;;;20489:2:14;14585:52:12;;;20471:21:14;20528:2;20508:18;;;20501:30;20567:28;20547:18;;;20540:56;20613:18;;14585:52:12;20287:350:14;14585:52:12;2752:7:4;14659:8:12;:33;;;;14651:77;;;;;;;20844:2:14;14651:77:12;;;20826:21:14;20883:2;20863:18;;;20856:30;20922:33;20902:18;;;20895:61;20973:18;;14651:77:12;20642:355:14;14651:77:12;14747:24;;;14743:65;;-1:-1:-1;14786:22:12;;;;;;;:12;:22;;;;;;;;14743:65;14830:24;;;14822:65;;;;;;;21204:2:14;14822:65:12;;;21186:21:14;21243:2;21223:18;;;21216:30;21282;21262:18;;;21255:58;21330:18;;14822:65:12;21002:352:14;14822:65:12;14902:25;14947:9;;;;:4;:9;:::i;:::-;14966;14986;14930:67;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;14902:95;;15012:12;15026:19;15049:10;:23;;15073:12;15049:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15011:75;;;;15105:14;15101:263;;;15139:31;15173:8;15182:1;15173:11;;;;;;;;:::i;:::-;;;;;;;;;;;;15202:19;;;;;15239:8;:17;;;-1:-1:-1;15101:263:12;;;15283:7;:26;;;-1:-1:-1;15294:15:12;;;;:4;:15;:::i;:::-;15277:87;;15330:19;15342:6;15330:11;:19::i;:::-;14331:1043;;;;;;;14326:3;;;;:::i;:::-;;;14291:1083;;;;15388:14;15384:60;;;15435:8;15411:33;;;;;;;;;;;:::i;15384:60::-;15460:6;15455:349;15472:31;;;15455:349;;;15524:15;15542:20;;15563:1;15542:23;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;15595:22;;;15580:12;15595:22;;;:13;:22;;;;;:43;;15652:66;;;;;;15524:41;;-1:-1:-1;15595:43:12;;1746:1:4;15737:31:12;;15733:60;;;15770:23;15785:7;15770:14;:23::i;:::-;15510:294;;15505:3;;;;:::i;:::-;;;15455:349;;;;13760:2050;;13632:2178;;;;;:::o;119:312:11:-;264:69;;;253:10;24132:15:14;;;264:69:11;;;24114:34:14;24184:15;;;24164:18;;;24157:43;24216:18;;;;24209:34;;;264:69:11;;;;;;;;;;24026:18:14;;;;264:69:11;;;;;;;;;287:28;264:69;;;253:81;;-1:-1:-1;;;;253:10:11;;;;:81;;264:69;253:81;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;217:117;;;;352:7;:57;;;;-1:-1:-1;364:11:11;;:16;;:44;;;395:4;384:24;;;;;;;;;;;;:::i;:::-;418:4;344:80;;;;;;;;;;;;;;:::i;:::-;;207:224;;119:312;;;;:::o;1063:258:0:-;1169:12;1206:22;;;:12;:22;;;;;;;:42;;1144:12;;1169;;;1206:22;;;;;:42;;1242:5;;1206:42;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1168:80;;;;1263:7;1258:33;;1272:19;1284:6;1272:11;:19::i;:::-;1308:6;1063:258;-1:-1:-1;;;;1063:258:0:o;2872:232::-;2942:13;;:17;2938:126;;3032:6;3026:13;3017:6;3013:2;3009:15;3002:38;2938:126;3074:23;;;;;24930:2:14;3074:23:0;;;24912:21:14;24969:2;24949:18;;;24942:30;25008:15;24988:18;;;24981:43;25041:18;;3074:23:0;24728:337:14;26728:376:2;26846:22;;;;26811:4;26846:22;;;:13;:22;;;;;:47;;;26811:4;;26846:47;26911:22;;;;;:85;;-1:-1:-1;26937:59:2;:23;;;;;;;:13;:23;;;;;:48;;;;;:59;;;;26911:85;:186;;27062:35;27089:7;27062:26;:35::i;:::-;26911:186;;;27011:36;27038:8;27011:26;:36::i;402:229::-;484:7;526:3;511:12;:18;503:55;;;;;;;25272:2:14;503:55:2;;;25254:21:14;25311:2;25291:18;;;25284:30;25350:26;25330:18;;;25323:54;25394:18;;503:55:2;25070:348:14;503:55:2;-1:-1:-1;583:40:2;;402:229::o;25082:446::-;25157:22;;;25142:12;25157:22;;;:13;:22;;;;;:43;;;25215:30;25211:311;;25304:71;;10269:42:14;10257:55;;25304:71:2;;;10239:74:14;25261:115:2;;2838:9:4;;25327:38:2;;10212:18:14;;25304:71:2;10093:226:14;25261:115:2;;25132:396;25082:446;:::o;25211:311::-;25397:31;;;1691:1:4;25397:31:2;25393:129;;;25444:22;;;;;;;:13;:22;;;;;:67;;;;1746:1:4;25444:67:2;;;25393:129;25132:396;25082:446;:::o;26287:435::-;26408:22;;;26358:4;26408:22;;;:13;:22;;;;;:49;;;;;;;26467:45;;-1:-1:-1;26511:1:2;;26287:435;-1:-1:-1;;26287:435:2:o;26467:45::-;26523:11;26537:44;26555:26;26537:15;:44;:::i;:::-;26523:58;-1:-1:-1;26595:11:2;26591:63;;-1:-1:-1;;;26615:22:2;;;;;;:13;:22;;;;;:39;;;;26287:435::o;26591:63::-;26672:43;26699:7;26708:6;25663:4;25679:17;1115:12:4;25699:6:2;:34;;:70;;25763:6;25699:70;;;1115:12:4;25699:70:2;25679:90;-1:-1:-1;25779:17:2;25799:39;25679:90;1115:12:4;25799:39:2;:::i;:::-;25779:59;;25849:25;25900:20;25922:19;25945:28;25965:7;25945:19;:28::i;:::-;25899:74;;;;26028:14;26010:15;:32;:71;;26080:1;26010:71;;;26045:32;26063:14;26045:15;:32;:::i;:::-;25987:94;;25885:207;;1115:12:4;26234::2;26211:20;:35;;;;:::i;:::-;:62;;;;:::i;:::-;26110:22;;;;;;;:13;:22;;;;;:39;;;1115:12:4;;26110:54:2;;26152:12;;26110:54;:::i;:::-;:81;;;;:::i;:::-;26109:165;;;;:::i;:::-;26102:172;25580:701;-1:-1:-1;;;;;;25580:701:2:o;24609:467::-;24791:71;;10269:42:14;10257:55;;24791:71:2;;;10239:74:14;24673:20:2;;;;;;24748:115;;2838:9:4;;24814:38:2;;10212:18:14;;24791:71:2;10093:226:14;24748:115:2;24726:137;;24874:42;24931:6;24920:50;;;;;;;;;;;;:::i;:::-;24999:22;;25048:21;;;;;24999:22;;25048:21;;-1:-1:-1;24609:467:2;-1:-1:-1;;;;24609:467:2:o;14:390:14:-;100:8;110:6;164:3;157:4;149:6;145:17;141:27;131:55;;182:1;179;172:12;131:55;-1:-1:-1;205:20:14;;248:18;237:30;;234:50;;;280:1;277;270:12;234:50;317:4;309:6;305:17;293:29;;377:3;370:4;360:6;357:1;353:14;345:6;341:27;337:38;334:47;331:67;;;394:1;391;384:12;331:67;14:390;;;;;:::o;409:853::-;565:6;573;581;589;642:2;630:9;621:7;617:23;613:32;610:52;;;658:1;655;648:12;610:52;698:9;685:23;727:18;768:2;760:6;757:14;754:34;;;784:1;781;774:12;754:34;823:93;908:7;899:6;888:9;884:22;823:93;:::i;:::-;935:8;;-1:-1:-1;797:119:14;-1:-1:-1;1023:2:14;1008:18;;995:32;;-1:-1:-1;1039:16:14;;;1036:36;;;1068:1;1065;1058:12;1036:36;;1107:95;1194:7;1183:8;1172:9;1168:24;1107:95;:::i;:::-;409:853;;;;-1:-1:-1;1221:8:14;-1:-1:-1;;;;409:853:14:o;1267:154::-;1353:42;1346:5;1342:54;1335:5;1332:65;1322:93;;1411:1;1408;1401:12;1322:93;1267:154;:::o;1426:118::-;1512:5;1505:13;1498:21;1491:5;1488:32;1478:60;;1534:1;1531;1524:12;1549:156;1615:20;;1675:4;1664:16;;1654:27;;1644:55;;1695:1;1692;1685:12;1644:55;1549:156;;;:::o;1710:728::-;1818:6;1826;1834;1842;1850;1858;1866;1919:3;1907:9;1898:7;1894:23;1890:33;1887:53;;;1936:1;1933;1926:12;1887:53;1975:9;1962:23;1994:31;2019:5;1994:31;:::i;:::-;2044:5;-1:-1:-1;2096:2:14;2081:18;;2068:32;;-1:-1:-1;2147:2:14;2132:18;;2119:32;;-1:-1:-1;2203:2:14;2188:18;;2175:32;2216:30;2175:32;2216:30;:::i;:::-;2265:7;-1:-1:-1;2291:37:14;2323:3;2308:19;;2291:37;:::i;:::-;2281:47;;2375:3;2364:9;2360:19;2347:33;2337:43;;2427:3;2416:9;2412:19;2399:33;2389:43;;1710:728;;;;;;;;;;:::o;2443:315::-;2511:6;2519;2572:2;2560:9;2551:7;2547:23;2543:32;2540:52;;;2588:1;2585;2578:12;2540:52;2627:9;2614:23;2646:31;2671:5;2646:31;:::i;:::-;2696:5;2748:2;2733:18;;;;2720:32;;-1:-1:-1;;;2443:315:14:o;2763:247::-;2822:6;2875:2;2863:9;2854:7;2850:23;2846:32;2843:52;;;2891:1;2888;2881:12;2843:52;2930:9;2917:23;2949:31;2974:5;2949:31;:::i;3268:184::-;3320:77;3317:1;3310:88;3417:4;3414:1;3407:15;3441:4;3438:1;3431:15;3457:257;3529:4;3523:11;;;3561:17;;3608:18;3593:34;;3629:22;;;3590:62;3587:88;;;3655:18;;:::i;:::-;3691:4;3684:24;3457:257;:::o;3719:334::-;3790:2;3784:9;3846:2;3836:13;;3851:66;3832:86;3820:99;;3949:18;3934:34;;3970:22;;;3931:62;3928:88;;;3996:18;;:::i;:::-;4032:2;4025:22;3719:334;;-1:-1:-1;3719:334:14:o;4058:957::-;4135:6;4143;4196:2;4184:9;4175:7;4171:23;4167:32;4164:52;;;4212:1;4209;4202:12;4164:52;4251:9;4238:23;4270:31;4295:5;4270:31;:::i;:::-;4320:5;-1:-1:-1;4344:2:14;4382:18;;;4369:32;4420:18;4450:14;;;4447:34;;;4477:1;4474;4467:12;4447:34;4515:6;4504:9;4500:22;4490:32;;4560:7;4553:4;4549:2;4545:13;4541:27;4531:55;;4582:1;4579;4572:12;4531:55;4618:2;4605:16;4640:2;4636;4633:10;4630:36;;;4646:18;;:::i;:::-;4688:112;4796:2;4727:66;4720:4;4716:2;4712:13;4708:86;4704:95;4688:112;:::i;:::-;4675:125;;4823:2;4816:5;4809:17;4863:7;4858:2;4853;4849;4845:11;4841:20;4838:33;4835:53;;;4884:1;4881;4874:12;4835:53;4939:2;4934;4930;4926:11;4921:2;4914:5;4910:14;4897:45;4983:1;4978:2;4973;4966:5;4962:14;4958:23;4951:34;;5004:5;4994:15;;;;;4058:957;;;;;:::o;5020:258::-;5092:1;5102:113;5116:6;5113:1;5110:13;5102:113;;;5192:11;;;5186:18;5173:11;;;5166:39;5138:2;5131:10;5102:113;;;5233:6;5230:1;5227:13;5224:48;;;-1:-1:-1;;5268:1:14;5250:16;;5243:27;5020:258::o;5283:316::-;5324:3;5362:5;5356:12;5389:6;5384:3;5377:19;5405:63;5461:6;5454:4;5449:3;5445:14;5438:4;5431:5;5427:16;5405:63;:::i;:::-;5513:2;5501:15;5518:66;5497:88;5488:98;;;;5588:4;5484:109;;5283:316;-1:-1:-1;;5283:316:14:o;5604:217::-;5751:2;5740:9;5733:21;5714:4;5771:44;5811:2;5800:9;5796:18;5788:6;5771:44;:::i;6190:450::-;6264:6;6272;6280;6333:2;6321:9;6312:7;6308:23;6304:32;6301:52;;;6349:1;6346;6339:12;6301:52;6385:9;6372:23;6362:33;;6445:2;6434:9;6430:18;6417:32;6458:31;6483:5;6458:31;:::i;:::-;6508:5;-1:-1:-1;6565:2:14;6550:18;;6537:32;6578:30;6537:32;6578:30;:::i;:::-;6627:7;6617:17;;;6190:450;;;;;:::o;6969:592::-;7071:6;7079;7087;7095;7103;7111;7164:3;7152:9;7143:7;7139:23;7135:33;7132:53;;;7181:1;7178;7171:12;7132:53;7220:9;7207:23;7239:31;7264:5;7239:31;:::i;:::-;7289:5;-1:-1:-1;7341:2:14;7326:18;;7313:32;;-1:-1:-1;7392:2:14;7377:18;;7364:32;;-1:-1:-1;7415:36:14;7447:2;7432:18;;7415:36;:::i;:::-;7405:46;;7498:3;7487:9;7483:19;7470:33;7460:43;;7550:3;7539:9;7535:19;7522:33;7512:43;;6969:592;;;;;;;;:::o;7855:271::-;7647:12;;7635:25;;7709:4;7698:16;;;7692:23;7676:14;;;7669:47;7765:4;7754:16;;;7748:23;7732:14;;;7725:47;7835:4;7824:16;;;7818:23;7811:31;7804:39;7788:14;;;7781:63;8055:3;8040:19;;8068:52;7566:284;8131:863;8228:6;8236;8244;8252;8260;8313:3;8301:9;8292:7;8288:23;8284:33;8281:53;;;8330:1;8327;8320:12;8281:53;8369:9;8356:23;8388:31;8413:5;8388:31;:::i;:::-;8438:5;-1:-1:-1;8490:2:14;8475:18;;8462:32;;-1:-1:-1;8541:2:14;8526:18;;8513:32;;-1:-1:-1;8596:2:14;8581:18;;8568:32;8619:18;8649:14;;;8646:34;;;8676:1;8673;8666:12;8646:34;8714:6;8703:9;8699:22;8689:32;;8759:7;8752:4;8748:2;8744:13;8740:27;8730:55;;8781:1;8778;8771:12;8730:55;8821:2;8808:16;8847:2;8839:6;8836:14;8833:34;;;8863:1;8860;8853:12;8833:34;8908:7;8903:2;8894:6;8890:2;8886:15;8882:24;8879:37;8876:57;;;8929:1;8926;8919:12;8876:57;8131:863;;;;-1:-1:-1;8131:863:14;;-1:-1:-1;8960:2:14;8952:11;;8982:6;8131:863;-1:-1:-1;;;8131:863:14:o;8999:180::-;9058:6;9111:2;9099:9;9090:7;9086:23;9082:32;9079:52;;;9127:1;9124;9117:12;9079:52;-1:-1:-1;9150:23:14;;8999:180;-1:-1:-1;8999:180:14:o;9184:904::-;9419:2;9471:21;;;9541:13;;9444:18;;;9563:22;;;9390:4;;9419:2;9642:15;;;;9616:2;9601:18;;;9390:4;9685:377;9699:6;9696:1;9693:13;9685:377;;;9758:13;;9800:9;;9811:42;9796:58;9784:71;;9894:11;;9888:18;9919:61;9967:12;;;9888:18;7653:5;7647:12;7642:3;7635:25;7709:4;7702:5;7698:16;7692:23;7685:4;7680:3;7676:14;7669:47;7765:4;7758:5;7754:16;7748:23;7741:4;7736:3;7732:14;7725:47;7835:4;7828:5;7824:16;7818:23;7811:31;7804:39;7797:4;7792:3;7788:14;7781:63;;;7566:284;9919:61;-1:-1:-1;10037:15:14;;;;10009:4;10000:14;;;;;9721:1;9714:9;9685:377;;;-1:-1:-1;10079:3:14;;9184:904;-1:-1:-1;;;;;;9184:904:14:o;12555:184::-;12625:6;12678:2;12666:9;12657:7;12653:23;12649:32;12646:52;;;12694:1;12691;12684:12;12646:52;-1:-1:-1;12717:16:14;;12555:184;-1:-1:-1;12555:184:14:o;12744:::-;12796:77;12793:1;12786:88;12893:4;12890:1;12883:15;12917:4;12914:1;12907:15;12933:128;12973:3;13004:1;13000:6;12997:1;12994:13;12991:39;;;13010:18;;:::i;:::-;-1:-1:-1;13046:9:14;;12933:128::o;13426:245::-;13505:6;13513;13566:2;13554:9;13545:7;13541:23;13537:32;13534:52;;;13582:1;13579;13572:12;13534:52;-1:-1:-1;;13605:16:14;;13661:2;13646:18;;;13640:25;13605:16;;13640:25;;-1:-1:-1;13426:245:14:o;13676:274::-;13805:3;13843:6;13837:13;13859:53;13905:6;13900:3;13893:4;13885:6;13881:17;13859:53;:::i;:::-;13928:16;;;;;13676:274;-1:-1:-1;;13676:274:14:o;14704:306::-;14792:6;14800;14808;14861:2;14849:9;14840:7;14836:23;14832:32;14829:52;;;14877:1;14874;14867:12;14829:52;14906:9;14900:16;14890:26;;14956:2;14945:9;14941:18;14935:25;14925:35;;15000:2;14989:9;14985:18;14979:25;14969:35;;14704:306;;;;;:::o;15713:665::-;15786:5;15834:4;15822:9;15817:3;15813:19;15809:30;15806:50;;;15852:1;15849;15842:12;15806:50;15885:2;15879:9;15927:4;15919:6;15915:17;15998:6;15986:10;15983:22;15962:18;15950:10;15947:34;15944:62;15941:88;;;16009:18;;:::i;:::-;16049:10;16045:2;16038:22;;16078:6;16069:15;;16114:9;16108:16;16100:6;16093:32;16179:2;16168:9;16164:18;16158:25;16153:2;16145:6;16141:15;16134:50;16238:2;16227:9;16223:18;16217:25;16212:2;16204:6;16200:15;16193:50;16288:2;16277:9;16273:18;16267:25;16301:30;16323:7;16301:30;:::i;:::-;16359:2;16347:15;;;;16340:32;15713:665;;-1:-1:-1;;15713:665:14:o;16383:266::-;16486:6;16539:3;16527:9;16518:7;16514:23;16510:33;16507:53;;;16556:1;16553;16546:12;16507:53;16579:64;16635:7;16624:9;16579:64;:::i;16654:816::-;16886:4;16915:42;16996:2;16988:6;16984:15;16973:9;16966:34;17048:2;17040:6;17036:15;17031:2;17020:9;17016:18;17009:43;;17088:6;17083:2;17072:9;17068:18;17061:34;17131:6;17126:2;17115:9;17111:18;17104:34;17175:3;17169;17158:9;17154:19;17147:32;17216:6;17210:3;17199:9;17195:19;17188:35;17274:6;17266;17260:3;17249:9;17245:19;17232:49;17331:1;17325:3;17316:6;17305:9;17301:22;17297:32;17290:43;17460:3;17390:66;17385:2;17377:6;17373:15;17369:88;17358:9;17354:104;17350:114;17342:122;;16654:816;;;;;;;;;:::o;17777:1374::-;17904:6;17935:2;17978;17966:9;17957:7;17953:23;17949:32;17946:52;;;17994:1;17991;17984:12;17946:52;18027:9;18021:16;18056:18;18097:2;18089:6;18086:14;18083:34;;;18113:1;18110;18103:12;18083:34;18151:6;18140:9;18136:22;18126:32;;18196:7;18189:4;18185:2;18181:13;18177:27;18167:55;;18218:1;18215;18208:12;18167:55;18247:2;18241:9;18269:2;18265;18262:10;18259:36;;;18275:18;;:::i;:::-;18315:36;18347:2;18342;18339:1;18335:10;18331:19;18315:36;:::i;:::-;18385:15;;;18416:12;;;;-1:-1:-1;18447:4:14;18486:11;;;18478:20;;18474:29;;;18515:19;;;18512:39;;;18547:1;18544;18537:12;18512:39;18571:11;;;;18591:530;18607:6;18602:3;18599:15;18591:530;;;18687:2;18681:3;18672:7;18668:17;18664:26;18661:116;;;18731:1;18760:2;18756;18749:14;18661:116;18803:22;;:::i;:::-;18859:3;18853:10;18876:33;18901:7;18876:33;:::i;:::-;18922:22;;18980:67;19039:7;19025:12;;;18980:67;:::i;:::-;18964:14;;;18957:91;19061:18;;18624:12;;;;19099;;;;18591:530;;;-1:-1:-1;19140:5:14;17777:1374;-1:-1:-1;;;;;;;17777:1374:14:o;19156:184::-;19208:77;19205:1;19198:88;19305:4;19302:1;19295:15;19329:4;19326:1;19319:15;19692:195;19731:3;19762:66;19755:5;19752:77;19749:103;;;19832:18;;:::i;:::-;-1:-1:-1;19879:1:14;19868:13;;19692:195::o;19892:390::-;19992:4;20050:11;20037:25;20140:66;20129:8;20113:14;20109:29;20105:102;20085:18;20081:127;20071:155;;20222:1;20219;20212:12;21359:580;21436:4;21442:6;21502:11;21489:25;21592:66;21581:8;21565:14;21561:29;21557:102;21537:18;21533:127;21523:155;;21674:1;21671;21664:12;21523:155;21701:33;;21753:20;;;-1:-1:-1;21796:18:14;21785:30;;21782:50;;;21828:1;21825;21818:12;21782:50;21861:4;21849:17;;-1:-1:-1;21892:14:14;21888:27;;;21878:38;;21875:58;;;21929:1;21926;21919:12;21944:520;22183:6;22175;22170:3;22157:33;22266:66;22360:2;22356:15;;;22352:24;;22209:16;;;;22341:36;;;22410:15;;22406:24;22401:2;22393:11;;22386:45;22455:2;22447:11;;;-1:-1:-1;21944:520:14:o;22469:241::-;22525:6;22578:2;22566:9;22557:7;22553:23;22549:32;22546:52;;;22594:1;22591;22584:12;22546:52;22633:9;22620:23;22652:28;22674:5;22652:28;:::i;22715:1131::-;22937:4;22966:2;23006;22995:9;22991:18;23036:2;23025:9;23018:21;23059:6;23094;23088:13;23125:6;23117;23110:22;23151:2;23141:12;;23184:2;23173:9;23169:18;23162:25;;23246:2;23236:6;23233:1;23229:14;23218:9;23214:30;23210:39;23284:2;23276:6;23272:15;23305:1;23315:502;23329:6;23326:1;23323:13;23315:502;;;23394:22;;;23418:66;23390:95;23378:108;;23509:13;;23564:9;;23557:17;23550:25;23535:41;;23615:11;;23609:18;23647:15;;;23640:27;;;23690:47;23721:15;;;23609:18;23690:47;:::i;:::-;23795:12;;;;23680:57;-1:-1:-1;;23760:15:14;;;;23351:1;23344:9;23315:502;;;-1:-1:-1;23834:6:14;;22715:1131;-1:-1:-1;;;;;;;;22715:1131:14:o;24254:245::-;24321:6;24374:2;24362:9;24353:7;24349:23;24345:32;24342:52;;;24390:1;24387;24380:12;24342:52;24422:9;24416:16;24441:28;24463:5;24441:28;:::i;25423:125::-;25463:4;25491:1;25488;25485:8;25482:34;;;25496:18;;:::i;:::-;-1:-1:-1;25533:9:14;;25423:125::o;25553:228::-;25593:7;25719:1;25651:66;25647:74;25644:1;25641:81;25636:1;25629:9;25622:17;25618:105;25615:131;;;25726:18;;:::i;:::-;-1:-1:-1;25766:9:14;;25553:228::o;25786:274::-;25826:1;25852;25842:189;;25887:77;25884:1;25877:88;25988:4;25985:1;25978:15;26016:4;26013:1;26006:15;25842:189;-1:-1:-1;26045:9:14;;25786:274::o

ipfs://29c97ce1591ff1136b4f54c2546a988108f66a4dfc79dc10a8afab17e17b2bd9