Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {IERC20} from "../../../dependencies/openzeppelin/contracts//IERC20.sol";
import {GPv2SafeERC20} from "../../../dependencies/gnosis/contracts/GPv2SafeERC20.sol";
import {PercentageMath} from "../../libraries/math/PercentageMath.sol";
import {WadRayMath} from "../../libraries/math/WadRayMath.sol";
import {Helpers} from "../../libraries/helpers/Helpers.sol";
import {DataTypes} from "../../libraries/types/DataTypes.sol";
import {ReserveLogic} from "./ReserveLogic.sol";
import {ValidationLogic} from "./ValidationLogic.sol";
import {GenericLogic} from "./GenericLogic.sol";
import {IsolationModeLogic} from "./IsolationModeLogic.sol";
import {EModeLogic} from "./EModeLogic.sol";
import {UserConfiguration} from "../../libraries/configuration/UserConfiguration.sol";
import {ReserveConfiguration} from "../../libraries/configuration/ReserveConfiguration.sol";
import {IAToken} from "../../../interfaces/IAToken.sol";
import {IStableDebtToken} from "../../../interfaces/IStableDebtToken.sol";
import {IVariableDebtToken} from "../../../interfaces/IVariableDebtToken.sol";
import {IPriceOracleGetter} from "../../../interfaces/IPriceOracleGetter.sol";

/**
 * @title LiquidationLogic library
 * @author Aave
 * @notice Implements actions involving management of collateral in the protocol, the main one being the liquidations
 */
library LiquidationLogic {
    using WadRayMath for uint256;
    using PercentageMath for uint256;
    using ReserveLogic for DataTypes.ReserveCache;
    using ReserveLogic for DataTypes.ReserveData;
    using UserConfiguration for DataTypes.UserConfigurationMap;
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
    using GPv2SafeERC20 for IERC20;

    // See `IPool` for descriptions
    event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);
    event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);
    event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateralAmount,
        address liquidator,
        bool receiveAToken
    );

    /**
     * @dev Default percentage of borrower's debt to be repaid in a liquidation.
     * @dev Percentage applied when the users health factor is above `CLOSE_FACTOR_HF_THRESHOLD`
     * Expressed in bps, a value of 0.5e4 results in 50.00%
     */
    uint256 internal constant DEFAULT_LIQUIDATION_CLOSE_FACTOR = 0.5e4;

    /**
     * @dev Maximum percentage of borrower's debt to be repaid in a liquidation
     * @dev Percentage applied when the users health factor is below `CLOSE_FACTOR_HF_THRESHOLD`
     * Expressed in bps, a value of 1e4 results in 100.00%
     */
    uint256 public constant MAX_LIQUIDATION_CLOSE_FACTOR = 1e4;

    /**
     * @dev This constant represents below which health factor value it is possible to liquidate
     * an amount of debt corresponding to `MAX_LIQUIDATION_CLOSE_FACTOR`.
     * A value of 0.95e18 results in 0.95
     */
    uint256 public constant CLOSE_FACTOR_HF_THRESHOLD = 0.95e18;

    struct LiquidationCallLocalVars {
        uint256 userCollateralBalance;
        uint256 userVariableDebt;
        uint256 userTotalDebt;
        uint256 actualDebtToLiquidate;
        uint256 actualCollateralToLiquidate;
        uint256 liquidationBonus;
        uint256 healthFactor;
        uint256 liquidationProtocolFeeAmount;
        address collateralPriceSource;
        address debtPriceSource;
        IAToken collateralAToken;
        DataTypes.ReserveCache debtReserveCache;
    }

    /**
     * @notice Function to liquidate a position if its Health Factor drops below 1. The caller (liquidator)
     * covers `debtToCover` amount of debt of the user getting liquidated, and receives
     * a proportional amount of the `collateralAsset` plus a bonus to cover market risk
     * @dev Emits the `LiquidationCall()` event
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param usersConfig The users configuration mapping that track the supplied/borrowed assets
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param params The additional parameters needed to execute the liquidation function
     */
    function executeLiquidationCall(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(address => DataTypes.UserConfigurationMap) storage usersConfig,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.ExecuteLiquidationCallParams memory params
    ) external {
        LiquidationCallLocalVars memory vars;

        DataTypes.ReserveData storage collateralReserve = reservesData[params.collateralAsset];
        DataTypes.ReserveData storage debtReserve = reservesData[params.debtAsset];
        DataTypes.UserConfigurationMap storage userConfig = usersConfig[params.user];
        vars.debtReserveCache = debtReserve.cache();
        debtReserve.updateState(vars.debtReserveCache);

        (,,,, vars.healthFactor,) = GenericLogic.calculateUserAccountData(
            reservesData,
            reservesList,
            eModeCategories,
            DataTypes.CalculateUserAccountDataParams({
                userConfig: userConfig,
                reservesCount: params.reservesCount,
                user: params.user,
                oracle: params.priceOracle,
                userEModeCategory: params.userEModeCategory
            })
        );

        (vars.userVariableDebt, vars.userTotalDebt, vars.actualDebtToLiquidate) =
            _calculateDebt(vars.debtReserveCache, params, vars.healthFactor);

        ValidationLogic.validateLiquidationCall(
            userConfig,
            collateralReserve,
            DataTypes.ValidateLiquidationCallParams({
                debtReserveCache: vars.debtReserveCache,
                totalDebt: vars.userTotalDebt,
                healthFactor: vars.healthFactor,
                priceOracleSentinel: params.priceOracleSentinel
            })
        );

        (vars.collateralAToken, vars.collateralPriceSource, vars.debtPriceSource, vars.liquidationBonus) =
            _getConfigurationData(eModeCategories, collateralReserve, params);

        vars.userCollateralBalance = vars.collateralAToken.balanceOf(params.user);

        (vars.actualCollateralToLiquidate, vars.actualDebtToLiquidate, vars.liquidationProtocolFeeAmount) = _calculateAvailableCollateralToLiquidate(
            collateralReserve,
            vars.debtReserveCache,
            vars.collateralPriceSource,
            vars.debtPriceSource,
            vars.actualDebtToLiquidate,
            vars.userCollateralBalance,
            vars.liquidationBonus,
            IPriceOracleGetter(params.priceOracle)
        );

        if (vars.userTotalDebt == vars.actualDebtToLiquidate) {
            userConfig.setBorrowing(debtReserve.id, false);
        }

        // If the collateral being liquidated is equal to the user balance,
        // we set the currency as not being used as collateral anymore
        if (vars.actualCollateralToLiquidate + vars.liquidationProtocolFeeAmount == vars.userCollateralBalance) {
            userConfig.setUsingAsCollateral(collateralReserve.id, false);
            emit ReserveUsedAsCollateralDisabled(params.collateralAsset, params.user);
        }

        _burnDebtTokens(params, vars);

        debtReserve.updateInterestRates(vars.debtReserveCache, params.debtAsset, vars.actualDebtToLiquidate, 0);

        IsolationModeLogic.updateIsolatedDebtIfIsolated(
            reservesData, reservesList, userConfig, vars.debtReserveCache, vars.actualDebtToLiquidate
        );

        if (params.receiveAToken) {
            _liquidateATokens(reservesData, reservesList, usersConfig, collateralReserve, params, vars);
        } else {
            _burnCollateralATokens(collateralReserve, params, vars);
        }

        // Transfer fee to treasury if it is non-zero
        if (vars.liquidationProtocolFeeAmount != 0) {
            uint256 liquidityIndex = collateralReserve.getNormalizedIncome();
            uint256 scaledDownLiquidationProtocolFee = vars.liquidationProtocolFeeAmount.rayDiv(liquidityIndex);
            uint256 scaledDownUserBalance = vars.collateralAToken.scaledBalanceOf(params.user);
            // To avoid trying to send more aTokens than available on balance, due to 1 wei imprecision
            if (scaledDownLiquidationProtocolFee > scaledDownUserBalance) {
                vars.liquidationProtocolFeeAmount = scaledDownUserBalance.rayMul(liquidityIndex);
            }
            vars.collateralAToken
                .transferOnLiquidation(
                    params.user, vars.collateralAToken.RESERVE_TREASURY_ADDRESS(), vars.liquidationProtocolFeeAmount
                );
        }

        // Transfers the debt asset being repaid to the aToken, where the liquidity is kept
        IERC20(params.debtAsset)
            .safeTransferFrom(msg.sender, vars.debtReserveCache.aTokenAddress, vars.actualDebtToLiquidate);

        IAToken(vars.debtReserveCache.aTokenAddress)
            .handleRepayment(msg.sender, params.user, vars.actualDebtToLiquidate);

        emit LiquidationCall(
            params.collateralAsset,
            params.debtAsset,
            params.user,
            vars.actualDebtToLiquidate,
            vars.actualCollateralToLiquidate,
            msg.sender,
            params.receiveAToken
        );
    }

    /**
     * @notice Burns the collateral aTokens and transfers the underlying to the liquidator.
     * @dev   The function also updates the state and the interest rate of the collateral reserve.
     * @param collateralReserve The data of the collateral reserve
     * @param params The additional parameters needed to execute the liquidation function
     * @param vars The executeLiquidationCall() function local vars
     */
    function _burnCollateralATokens(
        DataTypes.ReserveData storage collateralReserve,
        DataTypes.ExecuteLiquidationCallParams memory params,
        LiquidationCallLocalVars memory vars
    ) internal {
        DataTypes.ReserveCache memory collateralReserveCache = collateralReserve.cache();
        collateralReserve.updateState(collateralReserveCache);
        collateralReserve.updateInterestRates(
            collateralReserveCache, params.collateralAsset, 0, vars.actualCollateralToLiquidate
        );

        // Burn the equivalent amount of aToken, sending the underlying to the liquidator
        vars.collateralAToken
            .burn(params.user, msg.sender, vars.actualCollateralToLiquidate, collateralReserveCache.nextLiquidityIndex);
    }

    /**
     * @notice Liquidates the user aTokens by transferring them to the liquidator.
     * @dev   The function also checks the state of the liquidator and activates the aToken as collateral
     *        as in standard transfers if the isolation mode constraints are respected.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param usersConfig The users configuration mapping that track the supplied/borrowed assets
     * @param collateralReserve The data of the collateral reserve
     * @param params The additional parameters needed to execute the liquidation function
     * @param vars The executeLiquidationCall() function local vars
     */
    function _liquidateATokens(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(address => DataTypes.UserConfigurationMap) storage usersConfig,
        DataTypes.ReserveData storage collateralReserve,
        DataTypes.ExecuteLiquidationCallParams memory params,
        LiquidationCallLocalVars memory vars
    ) internal {
        uint256 liquidatorPreviousATokenBalance = IERC20(vars.collateralAToken).balanceOf(msg.sender);
        vars.collateralAToken.transferOnLiquidation(params.user, msg.sender, vars.actualCollateralToLiquidate);

        if (liquidatorPreviousATokenBalance == 0) {
            DataTypes.UserConfigurationMap storage liquidatorConfig = usersConfig[msg.sender];
            if (ValidationLogic.validateAutomaticUseAsCollateral(
                    reservesData,
                    reservesList,
                    liquidatorConfig,
                    collateralReserve.configuration,
                    collateralReserve.aTokenAddress
                )) {
                liquidatorConfig.setUsingAsCollateral(collateralReserve.id, true);
                emit ReserveUsedAsCollateralEnabled(params.collateralAsset, msg.sender);
            }
        }
    }

    /**
     * @notice Burns the debt tokens of the user up to the amount being repaid by the liquidator.
     * @dev The function alters the `debtReserveCache` state in `vars` to update the debt related data.
     * @param params The additional parameters needed to execute the liquidation function
     * @param vars the executeLiquidationCall() function local vars
     */
    function _burnDebtTokens(
        DataTypes.ExecuteLiquidationCallParams memory params,
        LiquidationCallLocalVars memory vars
    ) internal {
        if (vars.userVariableDebt >= vars.actualDebtToLiquidate) {
            vars.debtReserveCache.nextScaledVariableDebt = IVariableDebtToken(
                    vars.debtReserveCache.variableDebtTokenAddress
                ).burn(params.user, vars.actualDebtToLiquidate, vars.debtReserveCache.nextVariableBorrowIndex);
        } else {
            // If the user doesn't have variable debt, no need to try to burn variable debt tokens
            if (vars.userVariableDebt != 0) {
                vars.debtReserveCache.nextScaledVariableDebt = IVariableDebtToken(
                        vars.debtReserveCache.variableDebtTokenAddress
                    ).burn(params.user, vars.userVariableDebt, vars.debtReserveCache.nextVariableBorrowIndex);
            }
            (vars.debtReserveCache.nextTotalStableDebt, vars.debtReserveCache.nextAvgStableBorrowRate) = IStableDebtToken(
                    vars.debtReserveCache.stableDebtTokenAddress
                ).burn(params.user, vars.actualDebtToLiquidate - vars.userVariableDebt);
        }
    }

    /**
     * @notice Calculates the total debt of the user and the actual amount to liquidate depending on the health factor
     * and corresponding close factor.
     * @dev If the Health Factor is below CLOSE_FACTOR_HF_THRESHOLD, the close factor is increased to MAX_LIQUIDATION_CLOSE_FACTOR
     * @param debtReserveCache The reserve cache data object of the debt reserve
     * @param params The additional parameters needed to execute the liquidation function
     * @param healthFactor The health factor of the position
     * @return The variable debt of the user
     * @return The total debt of the user
     * @return The actual debt to liquidate as a function of the closeFactor
     */
    function _calculateDebt(
        DataTypes.ReserveCache memory debtReserveCache,
        DataTypes.ExecuteLiquidationCallParams memory params,
        uint256 healthFactor
    ) internal view returns (uint256, uint256, uint256) {
        (uint256 userStableDebt, uint256 userVariableDebt) = Helpers.getUserCurrentDebt(params.user, debtReserveCache);

        uint256 userTotalDebt = userStableDebt + userVariableDebt;

        uint256 closeFactor =
            healthFactor > CLOSE_FACTOR_HF_THRESHOLD ? DEFAULT_LIQUIDATION_CLOSE_FACTOR : MAX_LIQUIDATION_CLOSE_FACTOR;

        uint256 maxLiquidatableDebt = userTotalDebt.percentMul(closeFactor);

        uint256 actualDebtToLiquidate =
            params.debtToCover > maxLiquidatableDebt ? maxLiquidatableDebt : params.debtToCover;

        return (userVariableDebt, userTotalDebt, actualDebtToLiquidate);
    }

    /**
     * @notice Returns the configuration data for the debt and the collateral reserves.
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param collateralReserve The data of the collateral reserve
     * @param params The additional parameters needed to execute the liquidation function
     * @return The collateral aToken
     * @return The address to use as price source for the collateral
     * @return The address to use as price source for the debt
     * @return The liquidation bonus to apply to the collateral
     */
    function _getConfigurationData(
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.ReserveData storage collateralReserve,
        DataTypes.ExecuteLiquidationCallParams memory params
    ) internal view returns (IAToken, address, address, uint256) {
        IAToken collateralAToken = IAToken(collateralReserve.aTokenAddress);
        uint256 liquidationBonus = collateralReserve.configuration.getLiquidationBonus();

        address collateralPriceSource = params.collateralAsset;
        address debtPriceSource = params.debtAsset;

        if (params.userEModeCategory != 0) {
            address eModePriceSource = eModeCategories[params.userEModeCategory].priceSource;

            if (EModeLogic.isInEModeCategory(
                    params.userEModeCategory, collateralReserve.configuration.getEModeCategory()
                )) {
                liquidationBonus = eModeCategories[params.userEModeCategory].liquidationBonus;

                if (eModePriceSource != address(0)) {
                    collateralPriceSource = eModePriceSource;
                }
            }

            // when in eMode, debt will always be in the same eMode category, can skip matching category check
            if (eModePriceSource != address(0)) {
                debtPriceSource = eModePriceSource;
            }
        }

        return (collateralAToken, collateralPriceSource, debtPriceSource, liquidationBonus);
    }

    struct AvailableCollateralToLiquidateLocalVars {
        uint256 collateralPrice;
        uint256 debtAssetPrice;
        uint256 maxCollateralToLiquidate;
        uint256 baseCollateral;
        uint256 bonusCollateral;
        uint256 debtAssetDecimals;
        uint256 collateralDecimals;
        uint256 collateralAssetUnit;
        uint256 debtAssetUnit;
        uint256 collateralAmount;
        uint256 debtAmountNeeded;
        uint256 liquidationProtocolFeePercentage;
        uint256 liquidationProtocolFee;
    }

    /**
     * @notice Calculates how much of a specific collateral can be liquidated, given
     * a certain amount of debt asset.
     * @dev This function needs to be called after all the checks to validate the liquidation have been performed,
     *   otherwise it might fail.
     * @param collateralReserve The data of the collateral reserve
     * @param debtReserveCache The cached data of the debt reserve
     * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
     * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
     * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
     * @param userCollateralBalance The collateral balance for the specific `collateralAsset` of the user being liquidated
     * @param liquidationBonus The collateral bonus percentage to receive as result of the liquidation
     * @return The maximum amount that is possible to liquidate given all the liquidation constraints (user balance, close factor)
     * @return The amount to repay with the liquidation
     * @return The fee taken from the liquidation bonus amount to be paid to the protocol
     */
    function _calculateAvailableCollateralToLiquidate(
        DataTypes.ReserveData storage collateralReserve,
        DataTypes.ReserveCache memory debtReserveCache,
        address collateralAsset,
        address debtAsset,
        uint256 debtToCover,
        uint256 userCollateralBalance,
        uint256 liquidationBonus,
        IPriceOracleGetter oracle
    ) internal view returns (uint256, uint256, uint256) {
        AvailableCollateralToLiquidateLocalVars memory vars;

        vars.collateralPrice = oracle.getAssetPrice(collateralAsset);
        vars.debtAssetPrice = oracle.getAssetPrice(debtAsset);

        vars.collateralDecimals = collateralReserve.configuration.getDecimals();
        vars.debtAssetDecimals = debtReserveCache.reserveConfiguration.getDecimals();

        unchecked {
            vars.collateralAssetUnit = 10 ** vars.collateralDecimals;
            vars.debtAssetUnit = 10 ** vars.debtAssetDecimals;
        }

        vars.liquidationProtocolFeePercentage = collateralReserve.configuration.getLiquidationProtocolFee();

        // This is the base collateral to liquidate based on the given debt to cover
        vars.baseCollateral = ((vars.debtAssetPrice * debtToCover * vars.collateralAssetUnit))
            / (vars.collateralPrice * vars.debtAssetUnit);

        vars.maxCollateralToLiquidate = vars.baseCollateral.percentMul(liquidationBonus);

        if (vars.maxCollateralToLiquidate > userCollateralBalance) {
            vars.collateralAmount = userCollateralBalance;
            vars.debtAmountNeeded = ((vars.collateralPrice * vars.collateralAmount * vars.debtAssetUnit)
                    / (vars.debtAssetPrice * vars.collateralAssetUnit)).percentDiv(liquidationBonus);
        } else {
            vars.collateralAmount = vars.maxCollateralToLiquidate;
            vars.debtAmountNeeded = debtToCover;
        }

        if (vars.liquidationProtocolFeePercentage != 0) {
            vars.bonusCollateral = vars.collateralAmount - vars.collateralAmount.percentDiv(liquidationBonus);

            vars.liquidationProtocolFee = vars.bonusCollateral.percentMul(vars.liquidationProtocolFeePercentage);

            return
                (
                    vars.collateralAmount - vars.liquidationProtocolFee,
                    vars.debtAmountNeeded,
                    vars.liquidationProtocolFee
                );
        } else {
            return (vars.collateralAmount, vars.debtAmountNeeded, 0);
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: LGPL-3.0-or-later
pragma solidity ^0.8.0;

import {IERC20} from "../../openzeppelin/contracts/IERC20.sol";

/// @title Gnosis Protocol v2 Safe ERC20 Transfer Library
/// @author Gnosis Developers
/// @dev Gas-efficient version of Openzeppelin's SafeERC20 contract.
library GPv2SafeERC20 {
    /// @dev Wrapper around a call to the ERC20 function `transfer` that reverts
    /// also when the token returns `false`.
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        bytes4 selector_ = token.transfer.selector;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            let freeMemoryPointer := mload(0x40)
            mstore(freeMemoryPointer, selector_)
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff))
            mstore(add(freeMemoryPointer, 36), value)

            if iszero(call(gas(), token, 0, freeMemoryPointer, 68, 0, 0)) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }
        }

        require(getLastTransferResult(token), "GPv2: failed transfer");
    }

    /// @dev Wrapper around a call to the ERC20 function `transferFrom` that
    /// reverts also when the token returns `false`.
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        bytes4 selector_ = token.transferFrom.selector;

        // solhint-disable-next-line no-inline-assembly
        assembly {
            let freeMemoryPointer := mload(0x40)
            mstore(freeMemoryPointer, selector_)
            mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff))
            mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff))
            mstore(add(freeMemoryPointer, 68), value)

            if iszero(call(gas(), token, 0, freeMemoryPointer, 100, 0, 0)) {
                returndatacopy(0, 0, returndatasize())
                revert(0, returndatasize())
            }
        }

        require(getLastTransferResult(token), "GPv2: failed transferFrom");
    }

    /// @dev Verifies that the last return was a successful `transfer*` call.
    /// This is done by checking that the return data is either empty, or
    /// is a valid ABI encoded boolean.
    function getLastTransferResult(IERC20 token) private view returns (bool success) {
        // NOTE: Inspecting previous return data requires assembly. Note that
        // we write the return data to memory 0 in the case where the return
        // data size is 32, this is OK since the first 64 bytes of memory are
        // reserved by Solidy as a scratch space that can be used within
        // assembly blocks.
        // <https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html>
        // solhint-disable-next-line no-inline-assembly
        assembly {
            /// @dev Revert with an ABI encoded Solidity error with a message
            /// that fits into 32-bytes.
            ///
            /// An ABI encoded Solidity error has the following memory layout:
            ///
            /// ------------+----------------------------------
            ///  byte range | value
            /// ------------+----------------------------------
            ///  0x00..0x04 |        selector("Error(string)")
            ///  0x04..0x24 |      string offset (always 0x20)
            ///  0x24..0x44 |                    string length
            ///  0x44..0x64 | string value, padded to 32-bytes
            function revertWithMessage(length, message) {
                mstore(0x00, "\x08\xc3\x79\xa0")
                mstore(0x04, 0x20)
                mstore(0x24, length)
                mstore(0x44, message)
                revert(0x00, 0x64)
            }

            switch returndatasize()
            // Non-standard ERC20 transfer without return.
            case 0 {
                // NOTE: When the return data size is 0, verify that there
                // is code at the address. This is done in order to maintain
                // compatibility with Solidity calling conventions.
                // <https://docs.soliditylang.org/en/v0.7.6/control-structures.html#external-function-calls>
                if iszero(extcodesize(token)) {
                    revertWithMessage(20, "GPv2: not a contract")
                }

                success := 1
            }
            // Standard ERC20 transfer returning boolean success value.
            case 32 {
                returndatacopy(0, 0, returndatasize())

                // NOTE: For ABI encoding v1, any non-zero value is accepted
                // as `true` for a boolean. In order to stay compatible with
                // OpenZeppelin's `SafeERC20` library which is known to work
                // with the existing ERC20 implementation we care about,
                // make sure we return success for any non-zero return value
                // from the `transfer*` call.
                success := iszero(iszero(mload(0)))
            }
            default {
                revertWithMessage(31, "GPv2: malformed transfer result")
            }
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

/**
 * @title PercentageMath library
 * @author Aave
 * @notice Provides functions to perform percentage calculations
 * @dev Percentages are defined by default with 2 decimals of precision (100.00). The precision is indicated by PERCENTAGE_FACTOR
 * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
 */
library PercentageMath {
    // Maximum percentage factor (100.00%)
    uint256 internal constant PERCENTAGE_FACTOR = 1e4;

    // Half percentage factor (50.00%)
    uint256 internal constant HALF_PERCENTAGE_FACTOR = 0.5e4;

    /**
     * @notice Executes a percentage multiplication
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param value The value of which the percentage needs to be calculated
     * @param percentage The percentage of the value to be calculated
     * @return result value percentmul percentage
     */
    function percentMul(uint256 value, uint256 percentage) internal pure returns (uint256 result) {
        // to avoid overflow, value <= (type(uint256).max - HALF_PERCENTAGE_FACTOR) / percentage
        assembly {
            if iszero(or(iszero(percentage), iszero(gt(value, div(sub(not(0), HALF_PERCENTAGE_FACTOR), percentage))))) {
                revert(0, 0)
            }

            result := div(add(mul(value, percentage), HALF_PERCENTAGE_FACTOR), PERCENTAGE_FACTOR)
        }
    }

    /**
     * @notice Executes a percentage division
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param value The value of which the percentage needs to be calculated
     * @param percentage The percentage of the value to be calculated
     * @return result value percentdiv percentage
     */
    function percentDiv(uint256 value, uint256 percentage) internal pure returns (uint256 result) {
        // to avoid overflow, value <= (type(uint256).max - halfPercentage) / PERCENTAGE_FACTOR
        assembly {
            if or(
                iszero(percentage),
                iszero(iszero(gt(value, div(sub(not(0), div(percentage, 2)), PERCENTAGE_FACTOR))))
            ) {
                revert(0, 0)
            }

            result := div(add(mul(value, PERCENTAGE_FACTOR), div(percentage, 2)), percentage)
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

/**
 * @title WadRayMath library
 * @author Aave
 * @notice Provides functions to perform calculations with Wad and Ray units
 * @dev Provides mul and div function for wads (decimal numbers with 18 digits of precision) and rays (decimal numbers
 * with 27 digits of precision)
 * @dev Operations are rounded. If a value is >=.5, will be rounded up, otherwise rounded down.
 */
library WadRayMath {
    // HALF_WAD and HALF_RAY expressed with extended notation as constant with operations are not supported in Yul assembly
    uint256 internal constant WAD = 1e18;
    uint256 internal constant HALF_WAD = 0.5e18;

    uint256 internal constant RAY = 1e27;
    uint256 internal constant HALF_RAY = 0.5e27;

    uint256 internal constant WAD_RAY_RATIO = 1e9;

    /**
     * @dev Multiplies two wad, rounding half up to the nearest wad
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Wad
     * @param b Wad
     * @return c = a*b, in wad
     */
    function wadMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        // to avoid overflow, a <= (type(uint256).max - HALF_WAD) / b
        assembly {
            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_WAD), b))))) {
                revert(0, 0)
            }

            c := div(add(mul(a, b), HALF_WAD), WAD)
        }
    }

    /**
     * @dev Divides two wad, rounding half up to the nearest wad
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Wad
     * @param b Wad
     * @return c = a/b, in wad
     */
    function wadDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
        // to avoid overflow, a <= (type(uint256).max - halfB) / WAD
        assembly {
            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), WAD))))) {
                revert(0, 0)
            }

            c := div(add(mul(a, WAD), div(b, 2)), b)
        }
    }

    /**
     * @notice Multiplies two ray, rounding half up to the nearest ray
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Ray
     * @param b Ray
     * @return c = a raymul b
     */
    function rayMul(uint256 a, uint256 b) internal pure returns (uint256 c) {
        // to avoid overflow, a <= (type(uint256).max - HALF_RAY) / b
        assembly {
            if iszero(or(iszero(b), iszero(gt(a, div(sub(not(0), HALF_RAY), b))))) {
                revert(0, 0)
            }

            c := div(add(mul(a, b), HALF_RAY), RAY)
        }
    }

    /**
     * @notice Divides two ray, rounding half up to the nearest ray
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Ray
     * @param b Ray
     * @return c = a raydiv b
     */
    function rayDiv(uint256 a, uint256 b) internal pure returns (uint256 c) {
        // to avoid overflow, a <= (type(uint256).max - halfB) / RAY
        assembly {
            if or(iszero(b), iszero(iszero(gt(a, div(sub(not(0), div(b, 2)), RAY))))) {
                revert(0, 0)
            }

            c := div(add(mul(a, RAY), div(b, 2)), b)
        }
    }

    /**
     * @dev Casts ray down to wad
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Ray
     * @return b = a converted to wad, rounded half up to the nearest wad
     */
    function rayToWad(uint256 a) internal pure returns (uint256 b) {
        assembly {
            b := div(a, WAD_RAY_RATIO)
            let remainder := mod(a, WAD_RAY_RATIO)
            if iszero(lt(remainder, div(WAD_RAY_RATIO, 2))) {
                b := add(b, 1)
            }
        }
    }

    /**
     * @dev Converts wad up to ray
     * @dev assembly optimized for improved gas savings, see https://twitter.com/transmissions11/status/1451131036377571328
     * @param a Wad
     * @return b = a converted in ray
     */
    function wadToRay(uint256 a) internal pure returns (uint256 b) {
        // to avoid overflow, b/WAD_RAY_RATIO == a
        assembly {
            b := mul(a, WAD_RAY_RATIO)

            if iszero(eq(div(b, WAD_RAY_RATIO), a)) {
                revert(0, 0)
            }
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {DataTypes} from "../types/DataTypes.sol";

/**
 * @title Helpers library
 * @author Aave
 */
library Helpers {
    /**
     * @notice Fetches the user current stable and variable debt balances
     * @param user The user address
     * @param reserveCache The reserve cache data object
     * @return The stable debt balance
     * @return The variable debt balance
     */
    function getUserCurrentDebt(address user, DataTypes.ReserveCache memory reserveCache)
        internal
        view
        returns (uint256, uint256)
    {
        return (
            IERC20(reserveCache.stableDebtTokenAddress).balanceOf(user),
            IERC20(reserveCache.variableDebtTokenAddress).balanceOf(user)
        );
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

library DataTypes {
    struct ReserveData {
        //stores the reserve configuration
        ReserveConfigurationMap configuration;
        //the liquidity index. Expressed in ray
        uint128 liquidityIndex;
        //the current supply rate. Expressed in ray
        uint128 currentLiquidityRate;
        //variable borrow index. Expressed in ray
        uint128 variableBorrowIndex;
        //the current variable borrow rate. Expressed in ray
        uint128 currentVariableBorrowRate;
        //the current stable borrow rate. Expressed in ray
        uint128 currentStableBorrowRate;
        //timestamp of last update
        uint40 lastUpdateTimestamp;
        //the id of the reserve. Represents the position in the list of the active reserves
        uint16 id;
        //aToken address
        address aTokenAddress;
        //stableDebtToken address
        address stableDebtTokenAddress;
        //variableDebtToken address
        address variableDebtTokenAddress;
        //address of the interest rate strategy
        address interestRateStrategyAddress;
        //the current treasury balance, scaled
        uint128 accruedToTreasury;
        //the outstanding unbacked aTokens minted through the bridging feature
        uint128 unbacked;
        //the outstanding debt borrowed against this asset in isolation mode
        uint128 isolationModeTotalDebt;
    }

    struct ReserveConfigurationMap {
        //bit 0-15: LTV
        //bit 16-31: Liq. threshold
        //bit 32-47: Liq. bonus
        //bit 48-55: Decimals
        //bit 56: reserve is active
        //bit 57: reserve is frozen
        //bit 58: borrowing is enabled
        //bit 59: stable rate borrowing enabled
        //bit 60: asset is paused
        //bit 61: borrowing in isolation mode is enabled
        //bit 62: siloed borrowing enabled
        //bit 63: flashloaning enabled
        //bit 64-79: reserve factor
        //bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
        //bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
        //bit 152-167 liquidation protocol fee
        //bit 168-175 eMode category
        //bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
        //bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
        //bit 252-255 unused

        uint256 data;
    }

    struct UserConfigurationMap {
        /**
         * @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
         * The first bit indicates if an asset is used as collateral by the user, the second whether an
         * asset is borrowed by the user.
         */
        uint256 data;
    }

    struct EModeCategory {
        // each eMode category has a custom ltv and liquidation threshold
        uint16 ltv;
        uint16 liquidationThreshold;
        uint16 liquidationBonus;
        // each eMode category may or may not have a custom oracle to override the individual assets price oracles
        address priceSource;
        string label;
    }

    enum InterestRateMode {
        NONE,
        STABLE,
        VARIABLE
    }

    struct ReserveCache {
        uint256 currScaledVariableDebt;
        uint256 nextScaledVariableDebt;
        uint256 currPrincipalStableDebt;
        uint256 currAvgStableBorrowRate;
        uint256 currTotalStableDebt;
        uint256 nextAvgStableBorrowRate;
        uint256 nextTotalStableDebt;
        uint256 currLiquidityIndex;
        uint256 nextLiquidityIndex;
        uint256 currVariableBorrowIndex;
        uint256 nextVariableBorrowIndex;
        uint256 currLiquidityRate;
        uint256 currVariableBorrowRate;
        uint256 reserveFactor;
        ReserveConfigurationMap reserveConfiguration;
        address aTokenAddress;
        address stableDebtTokenAddress;
        address variableDebtTokenAddress;
        uint40 reserveLastUpdateTimestamp;
        uint40 stableDebtLastUpdateTimestamp;
    }

    struct ExecuteLiquidationCallParams {
        uint256 reservesCount;
        uint256 debtToCover;
        address collateralAsset;
        address debtAsset;
        address user;
        bool receiveAToken;
        address priceOracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
    }

    struct ExecuteSupplyParams {
        address asset;
        uint256 amount;
        address onBehalfOf;
        uint16 referralCode;
    }

    struct ExecuteBorrowParams {
        address asset;
        address user;
        address onBehalfOf;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint16 referralCode;
        bool releaseUnderlying;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
    }

    struct ExecuteRepayParams {
        address asset;
        uint256 amount;
        InterestRateMode interestRateMode;
        address onBehalfOf;
        bool useATokens;
    }

    struct ExecuteWithdrawParams {
        address asset;
        uint256 amount;
        address to;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
    }

    struct ExecuteSetUserEModeParams {
        uint256 reservesCount;
        address oracle;
        uint8 categoryId;
    }

    struct FinalizeTransferParams {
        address asset;
        address from;
        address to;
        uint256 amount;
        uint256 balanceFromBefore;
        uint256 balanceToBefore;
        uint256 reservesCount;
        address oracle;
        uint8 fromEModeCategory;
    }

    struct FlashloanParams {
        address receiverAddress;
        address[] assets;
        uint256[] amounts;
        uint256[] interestRateModes;
        address onBehalfOf;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
        uint256 maxStableRateBorrowSizePercent;
        uint256 reservesCount;
        address addressesProvider;
        uint8 userEModeCategory;
        bool isAuthorizedFlashBorrower;
    }

    struct FlashloanSimpleParams {
        address receiverAddress;
        address asset;
        uint256 amount;
        bytes params;
        uint16 referralCode;
        uint256 flashLoanPremiumToProtocol;
        uint256 flashLoanPremiumTotal;
    }

    struct FlashLoanRepaymentParams {
        uint256 amount;
        uint256 totalPremium;
        uint256 flashLoanPremiumToProtocol;
        address asset;
        address receiverAddress;
        uint16 referralCode;
    }

    struct CalculateUserAccountDataParams {
        UserConfigurationMap userConfig;
        uint256 reservesCount;
        address user;
        address oracle;
        uint8 userEModeCategory;
    }

    struct ValidateBorrowParams {
        ReserveCache reserveCache;
        UserConfigurationMap userConfig;
        address asset;
        address userAddress;
        uint256 amount;
        InterestRateMode interestRateMode;
        uint256 maxStableLoanPercent;
        uint256 reservesCount;
        address oracle;
        uint8 userEModeCategory;
        address priceOracleSentinel;
        bool isolationModeActive;
        address isolationModeCollateralAddress;
        uint256 isolationModeDebtCeiling;
    }

    struct ValidateLiquidationCallParams {
        ReserveCache debtReserveCache;
        uint256 totalDebt;
        uint256 healthFactor;
        address priceOracleSentinel;
    }

    struct CalculateInterestRatesParams {
        uint256 unbacked;
        uint256 liquidityAdded;
        uint256 liquidityTaken;
        uint256 totalStableDebt;
        uint256 totalVariableDebt;
        uint256 averageStableBorrowRate;
        uint256 reserveFactor;
        address reserve;
        address aToken;
    }

    struct InitReserveParams {
        address asset;
        address aTokenAddress;
        address stableDebtAddress;
        address variableDebtAddress;
        address interestRateStrategyAddress;
        uint16 reservesCount;
        uint16 maxNumberReserves;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {GPv2SafeERC20} from "../../../dependencies/gnosis/contracts/GPv2SafeERC20.sol";
import {IStableDebtToken} from "../../../interfaces/IStableDebtToken.sol";
import {IVariableDebtToken} from "../../../interfaces/IVariableDebtToken.sol";
import {IReserveInterestRateStrategy} from "../../../interfaces/IReserveInterestRateStrategy.sol";
import {ReserveConfiguration} from "../configuration/ReserveConfiguration.sol";
import {MathUtils} from "../math/MathUtils.sol";
import {WadRayMath} from "../math/WadRayMath.sol";
import {PercentageMath} from "../math/PercentageMath.sol";
import {Errors} from "../helpers/Errors.sol";
import {DataTypes} from "../types/DataTypes.sol";
import {SafeCast} from "../../../dependencies/openzeppelin/contracts/SafeCast.sol";

/**
 * @title ReserveLogic library
 * @author Aave
 * @notice Implements the logic to update the reserves state
 */
library ReserveLogic {
    using WadRayMath for uint256;
    using PercentageMath for uint256;
    using SafeCast for uint256;
    using GPv2SafeERC20 for IERC20;
    using ReserveLogic for DataTypes.ReserveData;
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;

    // See `IPool` for descriptions
    event ReserveDataUpdated(
        address indexed reserve,
        uint256 liquidityRate,
        uint256 stableBorrowRate,
        uint256 variableBorrowRate,
        uint256 liquidityIndex,
        uint256 variableBorrowIndex
    );

    /**
     * @notice Returns the ongoing normalized income for the reserve.
     * @dev A value of 1e27 means there is no income. As time passes, the income is accrued
     * @dev A value of 2*1e27 means for each unit of asset one unit of income has been accrued
     * @param reserve The reserve object
     * @return The normalized income, expressed in ray
     */
    function getNormalizedIncome(DataTypes.ReserveData storage reserve) internal view returns (uint256) {
        uint40 timestamp = reserve.lastUpdateTimestamp;

        //solium-disable-next-line
        if (timestamp == block.timestamp) {
            //if the index was updated in the same block, no need to perform any calculation
            return reserve.liquidityIndex;
        } else {
            return
                MathUtils.calculateLinearInterest(reserve.currentLiquidityRate, timestamp)
                    .rayMul(reserve.liquidityIndex);
        }
    }

    /**
     * @notice Returns the ongoing normalized variable debt for the reserve.
     * @dev A value of 1e27 means there is no debt. As time passes, the debt is accrued
     * @dev A value of 2*1e27 means that for each unit of debt, one unit worth of interest has been accumulated
     * @param reserve The reserve object
     * @return The normalized variable debt, expressed in ray
     */
    function getNormalizedDebt(DataTypes.ReserveData storage reserve) internal view returns (uint256) {
        uint40 timestamp = reserve.lastUpdateTimestamp;

        //solium-disable-next-line
        if (timestamp == block.timestamp) {
            //if the index was updated in the same block, no need to perform any calculation
            return reserve.variableBorrowIndex;
        } else {
            return MathUtils.calculateCompoundedInterest(reserve.currentVariableBorrowRate, timestamp)
                .rayMul(reserve.variableBorrowIndex);
        }
    }

    /**
     * @notice Updates the liquidity cumulative index and the variable borrow index.
     * @param reserve The reserve object
     * @param reserveCache The caching layer for the reserve data
     */
    function updateState(DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache) internal {
        // If time didn't pass since last stored timestamp, skip state update
        //solium-disable-next-line
        if (reserve.lastUpdateTimestamp == uint40(block.timestamp)) {
            return;
        }

        _updateIndexes(reserve, reserveCache);
        _accrueToTreasury(reserve, reserveCache);

        //solium-disable-next-line
        reserve.lastUpdateTimestamp = uint40(block.timestamp);
    }

    /**
     * @notice Accumulates a predefined amount of asset to the reserve as a fixed, instantaneous income. Used for example
     * to accumulate the flashloan fee to the reserve, and spread it between all the suppliers.
     * @param reserve The reserve object
     * @param totalLiquidity The total liquidity available in the reserve
     * @param amount The amount to accumulate
     * @return The next liquidity index of the reserve
     */
    function cumulateToLiquidityIndex(DataTypes.ReserveData storage reserve, uint256 totalLiquidity, uint256 amount)
        internal
        returns (uint256)
    {
        //next liquidity index is calculated this way: `((amount / totalLiquidity) + 1) * liquidityIndex`
        //division `amount / totalLiquidity` done in ray for precision
        uint256 result =
            (amount.wadToRay().rayDiv(totalLiquidity.wadToRay()) + WadRayMath.RAY).rayMul(reserve.liquidityIndex);
        reserve.liquidityIndex = result.toUint128();
        return result;
    }

    /**
     * @notice Initializes a reserve.
     * @param reserve The reserve object
     * @param aTokenAddress The address of the overlying atoken contract
     * @param stableDebtTokenAddress The address of the overlying stable debt token contract
     * @param variableDebtTokenAddress The address of the overlying variable debt token contract
     * @param interestRateStrategyAddress The address of the interest rate strategy contract
     */
    function init(
        DataTypes.ReserveData storage reserve,
        address aTokenAddress,
        address stableDebtTokenAddress,
        address variableDebtTokenAddress,
        address interestRateStrategyAddress
    ) internal {
        require(reserve.aTokenAddress == address(0), Errors.RESERVE_ALREADY_INITIALIZED);

        reserve.liquidityIndex = uint128(WadRayMath.RAY);
        reserve.variableBorrowIndex = uint128(WadRayMath.RAY);
        reserve.aTokenAddress = aTokenAddress;
        reserve.stableDebtTokenAddress = stableDebtTokenAddress;
        reserve.variableDebtTokenAddress = variableDebtTokenAddress;
        reserve.interestRateStrategyAddress = interestRateStrategyAddress;
    }

    struct UpdateInterestRatesLocalVars {
        uint256 nextLiquidityRate;
        uint256 nextStableRate;
        uint256 nextVariableRate;
        uint256 totalVariableDebt;
    }

    /**
     * @notice Updates the reserve current stable borrow rate, the current variable borrow rate and the current liquidity rate.
     * @param reserve The reserve reserve to be updated
     * @param reserveCache The caching layer for the reserve data
     * @param reserveAddress The address of the reserve to be updated
     * @param liquidityAdded The amount of liquidity added to the protocol (supply or repay) in the previous action
     * @param liquidityTaken The amount of liquidity taken from the protocol (redeem or borrow)
     */
    function updateInterestRates(
        DataTypes.ReserveData storage reserve,
        DataTypes.ReserveCache memory reserveCache,
        address reserveAddress,
        uint256 liquidityAdded,
        uint256 liquidityTaken
    ) internal {
        UpdateInterestRatesLocalVars memory vars;

        vars.totalVariableDebt = reserveCache.nextScaledVariableDebt.rayMul(reserveCache.nextVariableBorrowIndex);

        (vars.nextLiquidityRate, vars.nextStableRate, vars.nextVariableRate) = IReserveInterestRateStrategy(
                reserve.interestRateStrategyAddress
            )
            .calculateInterestRates(
                DataTypes.CalculateInterestRatesParams({
                    unbacked: reserve.unbacked,
                    liquidityAdded: liquidityAdded,
                    liquidityTaken: liquidityTaken,
                    totalStableDebt: reserveCache.nextTotalStableDebt,
                    totalVariableDebt: vars.totalVariableDebt,
                    averageStableBorrowRate: reserveCache.nextAvgStableBorrowRate,
                    reserveFactor: reserveCache.reserveFactor,
                    reserve: reserveAddress,
                    aToken: reserveCache.aTokenAddress
                })
            );

        reserve.currentLiquidityRate = vars.nextLiquidityRate.toUint128();
        reserve.currentStableBorrowRate = vars.nextStableRate.toUint128();
        reserve.currentVariableBorrowRate = vars.nextVariableRate.toUint128();

        emit ReserveDataUpdated(
            reserveAddress,
            vars.nextLiquidityRate,
            vars.nextStableRate,
            vars.nextVariableRate,
            reserveCache.nextLiquidityIndex,
            reserveCache.nextVariableBorrowIndex
        );
    }

    struct AccrueToTreasuryLocalVars {
        uint256 prevTotalStableDebt;
        uint256 prevTotalVariableDebt;
        uint256 currTotalVariableDebt;
        uint256 cumulatedStableInterest;
        uint256 totalDebtAccrued;
        uint256 amountToMint;
    }

    /**
     * @notice Mints part of the repaid interest to the reserve treasury as a function of the reserve factor for the
     * specific asset.
     * @param reserve The reserve to be updated
     * @param reserveCache The caching layer for the reserve data
     */
    function _accrueToTreasury(DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache)
        internal
    {
        AccrueToTreasuryLocalVars memory vars;

        if (reserveCache.reserveFactor == 0) {
            return;
        }

        //calculate the total variable debt at moment of the last interaction
        vars.prevTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul(reserveCache.currVariableBorrowIndex);

        //calculate the new total variable debt after accumulation of the interest on the index
        vars.currTotalVariableDebt = reserveCache.currScaledVariableDebt.rayMul(reserveCache.nextVariableBorrowIndex);

        //calculate the stable debt until the last timestamp update
        vars.cumulatedStableInterest = MathUtils.calculateCompoundedInterest(
            reserveCache.currAvgStableBorrowRate,
            reserveCache.stableDebtLastUpdateTimestamp,
            reserveCache.reserveLastUpdateTimestamp
        );

        vars.prevTotalStableDebt = reserveCache.currPrincipalStableDebt.rayMul(vars.cumulatedStableInterest);

        //debt accrued is the sum of the current debt minus the sum of the debt at the last update
        vars.totalDebtAccrued = vars.currTotalVariableDebt + reserveCache.currTotalStableDebt
            - vars.prevTotalVariableDebt - vars.prevTotalStableDebt;

        vars.amountToMint = vars.totalDebtAccrued.percentMul(reserveCache.reserveFactor);

        if (vars.amountToMint != 0) {
            reserve.accruedToTreasury += vars.amountToMint.rayDiv(reserveCache.nextLiquidityIndex).toUint128();
        }
    }

    /**
     * @notice Updates the reserve indexes and the timestamp of the update.
     * @param reserve The reserve reserve to be updated
     * @param reserveCache The cache layer holding the cached protocol data
     */
    function _updateIndexes(DataTypes.ReserveData storage reserve, DataTypes.ReserveCache memory reserveCache)
        internal
    {
        // Only cumulating on the supply side if there is any income being produced
        // The case of Reserve Factor 100% is not a problem (currentLiquidityRate == 0),
        // as liquidity index should not be updated
        if (reserveCache.currLiquidityRate != 0) {
            uint256 cumulatedLiquidityInterest = MathUtils.calculateLinearInterest(
                reserveCache.currLiquidityRate, reserveCache.reserveLastUpdateTimestamp
            );
            reserveCache.nextLiquidityIndex = cumulatedLiquidityInterest.rayMul(reserveCache.currLiquidityIndex);
            reserve.liquidityIndex = reserveCache.nextLiquidityIndex.toUint128();
        }

        // Variable borrow index only gets updated if there is any variable debt.
        // reserveCache.currVariableBorrowRate != 0 is not a correct validation,
        // because a positive base variable rate can be stored on
        // reserveCache.currVariableBorrowRate, but the index should not increase
        if (reserveCache.currScaledVariableDebt != 0) {
            uint256 cumulatedVariableBorrowInterest = MathUtils.calculateCompoundedInterest(
                reserveCache.currVariableBorrowRate, reserveCache.reserveLastUpdateTimestamp
            );
            reserveCache.nextVariableBorrowIndex =
                cumulatedVariableBorrowInterest.rayMul(reserveCache.currVariableBorrowIndex);
            reserve.variableBorrowIndex = reserveCache.nextVariableBorrowIndex.toUint128();
        }
    }

    /**
     * @notice Creates a cache object to avoid repeated storage reads and external contract calls when updating state and
     * interest rates.
     * @param reserve The reserve object for which the cache will be filled
     * @return The cache object
     */
    function cache(DataTypes.ReserveData storage reserve) internal view returns (DataTypes.ReserveCache memory) {
        DataTypes.ReserveCache memory reserveCache;

        reserveCache.reserveConfiguration = reserve.configuration;
        reserveCache.reserveFactor = reserveCache.reserveConfiguration.getReserveFactor();
        reserveCache.currLiquidityIndex = reserveCache.nextLiquidityIndex = reserve.liquidityIndex;
        reserveCache.currVariableBorrowIndex = reserveCache.nextVariableBorrowIndex = reserve.variableBorrowIndex;
        reserveCache.currLiquidityRate = reserve.currentLiquidityRate;
        reserveCache.currVariableBorrowRate = reserve.currentVariableBorrowRate;

        reserveCache.aTokenAddress = reserve.aTokenAddress;
        reserveCache.stableDebtTokenAddress = reserve.stableDebtTokenAddress;
        reserveCache.variableDebtTokenAddress = reserve.variableDebtTokenAddress;

        reserveCache.reserveLastUpdateTimestamp = reserve.lastUpdateTimestamp;

        reserveCache.currScaledVariableDebt = reserveCache.nextScaledVariableDebt =
            IVariableDebtToken(reserveCache.variableDebtTokenAddress).scaledTotalSupply();

        (
                reserveCache.currPrincipalStableDebt,
                reserveCache.currTotalStableDebt,
                reserveCache.currAvgStableBorrowRate,
                reserveCache.stableDebtLastUpdateTimestamp
            ) = IStableDebtToken(reserveCache.stableDebtTokenAddress).getSupplyData();

        // by default the actions are considered as not affecting the debt balances.
        // if the action involves mint/burn of debt, the cache needs to be updated
        reserveCache.nextTotalStableDebt = reserveCache.currTotalStableDebt;
        reserveCache.nextAvgStableBorrowRate = reserveCache.currAvgStableBorrowRate;

        return reserveCache;
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {Address} from "../../../dependencies/openzeppelin/contracts/Address.sol";
import {GPv2SafeERC20} from "../../../dependencies/gnosis/contracts/GPv2SafeERC20.sol";
import {IReserveInterestRateStrategy} from "../../../interfaces/IReserveInterestRateStrategy.sol";
import {IStableDebtToken} from "../../../interfaces/IStableDebtToken.sol";
import {IScaledBalanceToken} from "../../../interfaces/IScaledBalanceToken.sol";
import {IPriceOracleGetter} from "../../../interfaces/IPriceOracleGetter.sol";
import {IAToken} from "../../../interfaces/IAToken.sol";
import {IPriceOracleSentinel} from "../../../interfaces/IPriceOracleSentinel.sol";
import {IPoolAddressesProvider} from "../../../interfaces/IPoolAddressesProvider.sol";
import {IAccessControl} from "../../../dependencies/openzeppelin/contracts/IAccessControl.sol";
import {ReserveConfiguration} from "../configuration/ReserveConfiguration.sol";
import {UserConfiguration} from "../configuration/UserConfiguration.sol";
import {Errors} from "../helpers/Errors.sol";
import {WadRayMath} from "../math/WadRayMath.sol";
import {PercentageMath} from "../math/PercentageMath.sol";
import {DataTypes} from "../types/DataTypes.sol";
import {ReserveLogic} from "./ReserveLogic.sol";
import {GenericLogic} from "./GenericLogic.sol";
import {SafeCast} from "../../../dependencies/openzeppelin/contracts/SafeCast.sol";
import {IncentivizedERC20} from "../../tokenization/base/IncentivizedERC20.sol";

/**
 * @title ReserveLogic library
 * @author Aave
 * @notice Implements functions to validate the different actions of the protocol
 */
library ValidationLogic {
    using ReserveLogic for DataTypes.ReserveData;
    using WadRayMath for uint256;
    using PercentageMath for uint256;
    using SafeCast for uint256;
    using GPv2SafeERC20 for IERC20;
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
    using UserConfiguration for DataTypes.UserConfigurationMap;
    using Address for address;

    // Factor to apply to "only-variable-debt" liquidity rate to get threshold for rebalancing, expressed in bps
    // A value of 0.9e4 results in 90%
    uint256 public constant REBALANCE_UP_LIQUIDITY_RATE_THRESHOLD = 0.9e4;

    // Minimum health factor allowed under any circumstance
    // A value of 0.95e18 results in 0.95
    uint256 public constant MINIMUM_HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 0.95e18;

    /**
     * @dev Minimum health factor to consider a user position healthy
     * A value of 1e18 results in 1
     */
    uint256 public constant HEALTH_FACTOR_LIQUIDATION_THRESHOLD = 1e18;

    /**
     * @dev Role identifier for the role allowed to supply isolated reserves as collateral
     */
    bytes32 public constant ISOLATED_COLLATERAL_SUPPLIER_ROLE = keccak256("ISOLATED_COLLATERAL_SUPPLIER");

    /**
     * @notice Validates a supply action.
     * @param reserveCache The cached data of the reserve
     * @param amount The amount to be supplied
     */
    function validateSupply(
        DataTypes.ReserveCache memory reserveCache,
        DataTypes.ReserveData storage reserve,
        uint256 amount
    ) internal view {
        require(amount != 0, Errors.INVALID_AMOUNT);

        (bool isActive, bool isFrozen,,, bool isPaused) = reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);
        require(!isFrozen, Errors.RESERVE_FROZEN);

        uint256 supplyCap = reserveCache.reserveConfiguration.getSupplyCap();
        require(
            supplyCap == 0
                || ((IAToken(reserveCache.aTokenAddress).scaledTotalSupply() + uint256(reserve.accruedToTreasury))
                        .rayMul(reserveCache.nextLiquidityIndex) + amount)
                    <= supplyCap * (10 ** reserveCache.reserveConfiguration.getDecimals()),
            Errors.SUPPLY_CAP_EXCEEDED
        );
    }

    /**
     * @notice Validates a withdraw action.
     * @param reserveCache The cached data of the reserve
     * @param amount The amount to be withdrawn
     * @param userBalance The balance of the user
     */
    function validateWithdraw(DataTypes.ReserveCache memory reserveCache, uint256 amount, uint256 userBalance)
        internal
        pure
    {
        require(amount != 0, Errors.INVALID_AMOUNT);
        require(amount <= userBalance, Errors.NOT_ENOUGH_AVAILABLE_USER_BALANCE);

        (bool isActive,,,, bool isPaused) = reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);
    }

    struct ValidateBorrowLocalVars {
        uint256 currentLtv;
        uint256 collateralNeededInBaseCurrency;
        uint256 userCollateralInBaseCurrency;
        uint256 userDebtInBaseCurrency;
        uint256 availableLiquidity;
        uint256 healthFactor;
        uint256 totalDebt;
        uint256 totalSupplyVariableDebt;
        uint256 reserveDecimals;
        uint256 borrowCap;
        uint256 amountInBaseCurrency;
        uint256 assetUnit;
        address eModePriceSource;
        address siloedBorrowingAddress;
        bool isActive;
        bool isFrozen;
        bool isPaused;
        bool borrowingEnabled;
        bool stableRateBorrowingEnabled;
        bool siloedBorrowingEnabled;
    }

    /**
     * @notice Validates a borrow action.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param params Additional params needed for the validation
     */
    function validateBorrow(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.ValidateBorrowParams memory params
    ) internal view {
        require(params.amount != 0, Errors.INVALID_AMOUNT);

        ValidateBorrowLocalVars memory vars;

        (vars.isActive, vars.isFrozen, vars.borrowingEnabled, vars.stableRateBorrowingEnabled, vars.isPaused) =
            params.reserveCache.reserveConfiguration.getFlags();

        require(vars.isActive, Errors.RESERVE_INACTIVE);
        require(!vars.isPaused, Errors.RESERVE_PAUSED);
        require(!vars.isFrozen, Errors.RESERVE_FROZEN);
        require(vars.borrowingEnabled, Errors.BORROWING_NOT_ENABLED);

        require(
            params.priceOracleSentinel == address(0)
                || IPriceOracleSentinel(params.priceOracleSentinel).isBorrowAllowed(),
            Errors.PRICE_ORACLE_SENTINEL_CHECK_FAILED
        );

        //validate interest rate mode
        require(
            params.interestRateMode == DataTypes.InterestRateMode.VARIABLE
                || params.interestRateMode == DataTypes.InterestRateMode.STABLE,
            Errors.INVALID_INTEREST_RATE_MODE_SELECTED
        );

        vars.reserveDecimals = params.reserveCache.reserveConfiguration.getDecimals();
        vars.borrowCap = params.reserveCache.reserveConfiguration.getBorrowCap();
        unchecked {
            vars.assetUnit = 10 ** vars.reserveDecimals;
        }

        if (vars.borrowCap != 0) {
            vars.totalSupplyVariableDebt =
                params.reserveCache.currScaledVariableDebt.rayMul(params.reserveCache.nextVariableBorrowIndex);

            vars.totalDebt = params.reserveCache.currTotalStableDebt + vars.totalSupplyVariableDebt + params.amount;

            unchecked {
                require(vars.totalDebt <= vars.borrowCap * vars.assetUnit, Errors.BORROW_CAP_EXCEEDED);
            }
        }

        if (params.isolationModeActive) {
            // check that the asset being borrowed is borrowable in isolation mode AND
            // the total exposure is no bigger than the collateral debt ceiling
            require(
                params.reserveCache.reserveConfiguration.getBorrowableInIsolation(),
                Errors.ASSET_NOT_BORROWABLE_IN_ISOLATION
            );

            require(
                reservesData[params.isolationModeCollateralAddress].isolationModeTotalDebt
                        + (params.amount / 10 ** (vars.reserveDecimals - ReserveConfiguration.DEBT_CEILING_DECIMALS))
                        .toUint128() <= params.isolationModeDebtCeiling,
                Errors.DEBT_CEILING_EXCEEDED
            );
        }

        if (params.userEModeCategory != 0) {
            require(
                params.reserveCache.reserveConfiguration.getEModeCategory() == params.userEModeCategory,
                Errors.INCONSISTENT_EMODE_CATEGORY
            );
            vars.eModePriceSource = eModeCategories[params.userEModeCategory].priceSource;
        }

        (vars.userCollateralInBaseCurrency, vars.userDebtInBaseCurrency, vars.currentLtv,, vars.healthFactor,) = GenericLogic.calculateUserAccountData(
            reservesData,
            reservesList,
            eModeCategories,
            DataTypes.CalculateUserAccountDataParams({
                userConfig: params.userConfig,
                reservesCount: params.reservesCount,
                user: params.userAddress,
                oracle: params.oracle,
                userEModeCategory: params.userEModeCategory
            })
        );

        require(vars.userCollateralInBaseCurrency != 0, Errors.COLLATERAL_BALANCE_IS_ZERO);
        require(vars.currentLtv != 0, Errors.LTV_VALIDATION_FAILED);

        require(
            vars.healthFactor > HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
            Errors.HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD
        );

        vars.amountInBaseCurrency = IPriceOracleGetter(params.oracle)
                .getAssetPrice(vars.eModePriceSource != address(0) ? vars.eModePriceSource : params.asset)
            * params.amount;
        unchecked {
            vars.amountInBaseCurrency /= vars.assetUnit;
        }

        //add the current already borrowed amount to the amount requested to calculate the total collateral needed.
        vars.collateralNeededInBaseCurrency =
            (vars.userDebtInBaseCurrency + vars.amountInBaseCurrency).percentDiv(vars.currentLtv); //LTV is calculated in percentage

        require(
            vars.collateralNeededInBaseCurrency <= vars.userCollateralInBaseCurrency,
            Errors.COLLATERAL_CANNOT_COVER_NEW_BORROW
        );

        /**
         * Following conditions need to be met if the user is borrowing at a stable rate:
         * 1. Reserve must be enabled for stable rate borrowing
         * 2. Users cannot borrow from the reserve if their collateral is (mostly) the same currency
         *    they are borrowing, to prevent abuses.
         * 3. Users will be able to borrow only a portion of the total available liquidity
         */

        if (params.interestRateMode == DataTypes.InterestRateMode.STABLE) {
            //check if the borrow mode is stable and if stable rate borrowing is enabled on this reserve

            require(vars.stableRateBorrowingEnabled, Errors.STABLE_BORROWING_NOT_ENABLED);

            require(
                !params.userConfig.isUsingAsCollateral(reservesData[params.asset].id)
                    || params.reserveCache.reserveConfiguration.getLtv() == 0
                    || params.amount > IERC20(params.reserveCache.aTokenAddress).balanceOf(params.userAddress),
                Errors.COLLATERAL_SAME_AS_BORROWING_CURRENCY
            );

            vars.availableLiquidity = IERC20(params.asset).balanceOf(params.reserveCache.aTokenAddress);

            //calculate the max available loan size in stable rate mode as a percentage of the
            //available liquidity
            uint256 maxLoanSizeStable = vars.availableLiquidity.percentMul(params.maxStableLoanPercent);

            require(params.amount <= maxLoanSizeStable, Errors.AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE);
        }

        if (params.userConfig.isBorrowingAny()) {
            (vars.siloedBorrowingEnabled, vars.siloedBorrowingAddress) =
                params.userConfig.getSiloedBorrowingState(reservesData, reservesList);

            if (vars.siloedBorrowingEnabled) {
                require(vars.siloedBorrowingAddress == params.asset, Errors.SILOED_BORROWING_VIOLATION);
            } else {
                require(
                    !params.reserveCache.reserveConfiguration.getSiloedBorrowing(), Errors.SILOED_BORROWING_VIOLATION
                );
            }
        }
    }

    /**
     * @notice Validates a repay action.
     * @param reserveCache The cached data of the reserve
     * @param amountSent The amount sent for the repayment. Can be an actual value or uint(-1)
     * @param interestRateMode The interest rate mode of the debt being repaid
     * @param onBehalfOf The address of the user msg.sender is repaying for
     * @param stableDebt The borrow balance of the user
     * @param variableDebt The borrow balance of the user
     */
    function validateRepay(
        DataTypes.ReserveCache memory reserveCache,
        uint256 amountSent,
        DataTypes.InterestRateMode interestRateMode,
        address onBehalfOf,
        uint256 stableDebt,
        uint256 variableDebt
    ) internal view {
        require(amountSent != 0, Errors.INVALID_AMOUNT);
        require(
            amountSent != type(uint256).max || msg.sender == onBehalfOf, Errors.NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF
        );

        (bool isActive,,,, bool isPaused) = reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);

        require(
            (stableDebt != 0 && interestRateMode == DataTypes.InterestRateMode.STABLE)
                || (variableDebt != 0 && interestRateMode == DataTypes.InterestRateMode.VARIABLE),
            Errors.NO_DEBT_OF_SELECTED_TYPE
        );
    }

    /**
     * @notice Validates a swap of borrow rate mode.
     * @param reserve The reserve state on which the user is swapping the rate
     * @param reserveCache The cached data of the reserve
     * @param userConfig The user reserves configuration
     * @param stableDebt The stable debt of the user
     * @param variableDebt The variable debt of the user
     * @param currentRateMode The rate mode of the debt being swapped
     */
    function validateSwapRateMode(
        DataTypes.ReserveData storage reserve,
        DataTypes.ReserveCache memory reserveCache,
        DataTypes.UserConfigurationMap storage userConfig,
        uint256 stableDebt,
        uint256 variableDebt,
        DataTypes.InterestRateMode currentRateMode
    ) internal view {
        (bool isActive, bool isFrozen,, bool stableRateEnabled, bool isPaused) =
            reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);
        require(!isFrozen, Errors.RESERVE_FROZEN);

        if (currentRateMode == DataTypes.InterestRateMode.STABLE) {
            require(stableDebt != 0, Errors.NO_OUTSTANDING_STABLE_DEBT);
        } else if (currentRateMode == DataTypes.InterestRateMode.VARIABLE) {
            require(variableDebt != 0, Errors.NO_OUTSTANDING_VARIABLE_DEBT);
            /**
             * user wants to swap to stable, before swapping we need to ensure that
             * 1. stable borrow rate is enabled on the reserve
             * 2. user is not trying to abuse the reserve by supplying
             * more collateral than he is borrowing, artificially lowering
             * the interest rate, borrowing at variable, and switching to stable
             */
            require(stableRateEnabled, Errors.STABLE_BORROWING_NOT_ENABLED);

            require(
                !userConfig.isUsingAsCollateral(reserve.id) || reserveCache.reserveConfiguration.getLtv() == 0
                    || stableDebt + variableDebt > IERC20(reserveCache.aTokenAddress).balanceOf(msg.sender),
                Errors.COLLATERAL_SAME_AS_BORROWING_CURRENCY
            );
        } else {
            revert(Errors.INVALID_INTEREST_RATE_MODE_SELECTED);
        }
    }

    /**
     * @notice Validates a stable borrow rate rebalance action.
     * @dev Rebalancing is accepted when depositors are earning <= 90% of their earnings in pure supply/demand market (variable rate only)
     * For this to be the case, there has to be quite large stable debt with an interest rate below the current variable rate.
     * @param reserve The reserve state on which the user is getting rebalanced
     * @param reserveCache The cached state of the reserve
     * @param reserveAddress The address of the reserve
     */
    function validateRebalanceStableBorrowRate(
        DataTypes.ReserveData storage reserve,
        DataTypes.ReserveCache memory reserveCache,
        address reserveAddress
    ) internal view {
        (bool isActive,,,, bool isPaused) = reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);

        uint256 totalDebt =
            IERC20(reserveCache.stableDebtTokenAddress).totalSupply()
            + IERC20(reserveCache.variableDebtTokenAddress).totalSupply();

        (uint256 liquidityRateVariableDebtOnly,,) = IReserveInterestRateStrategy(reserve.interestRateStrategyAddress)
            .calculateInterestRates(
                DataTypes.CalculateInterestRatesParams({
                    unbacked: reserve.unbacked,
                    liquidityAdded: 0,
                    liquidityTaken: 0,
                    totalStableDebt: 0,
                    totalVariableDebt: totalDebt,
                    averageStableBorrowRate: 0,
                    reserveFactor: reserveCache.reserveFactor,
                    reserve: reserveAddress,
                    aToken: reserveCache.aTokenAddress
                })
            );

        require(
            reserveCache.currLiquidityRate
                <= liquidityRateVariableDebtOnly.percentMul(REBALANCE_UP_LIQUIDITY_RATE_THRESHOLD),
            Errors.INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET
        );
    }

    /**
     * @notice Validates the action of setting an asset as collateral.
     * @param reserveCache The cached data of the reserve
     * @param userBalance The balance of the user
     */
    function validateSetUseReserveAsCollateral(DataTypes.ReserveCache memory reserveCache, uint256 userBalance)
        internal
        pure
    {
        require(userBalance != 0, Errors.UNDERLYING_BALANCE_ZERO);

        (bool isActive,,,, bool isPaused) = reserveCache.reserveConfiguration.getFlags();
        require(isActive, Errors.RESERVE_INACTIVE);
        require(!isPaused, Errors.RESERVE_PAUSED);
    }

    /**
     * @notice Validates a flashloan action.
     * @param reservesData The state of all the reserves
     * @param assets The assets being flash-borrowed
     * @param amounts The amounts for each asset being borrowed
     */
    function validateFlashloan(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        address[] memory assets,
        uint256[] memory amounts
    ) internal view {
        require(assets.length == amounts.length, Errors.INCONSISTENT_FLASHLOAN_PARAMS);
        for (uint256 i = 0; i < assets.length; i++) {
            validateFlashloanSimple(reservesData[assets[i]]);
        }
    }

    /**
     * @notice Validates a flashloan action.
     * @param reserve The state of the reserve
     */
    function validateFlashloanSimple(DataTypes.ReserveData storage reserve) internal view {
        DataTypes.ReserveConfigurationMap memory configuration = reserve.configuration;
        require(!configuration.getPaused(), Errors.RESERVE_PAUSED);
        require(configuration.getActive(), Errors.RESERVE_INACTIVE);
        require(configuration.getFlashLoanEnabled(), Errors.FLASHLOAN_DISABLED);
    }

    struct ValidateLiquidationCallLocalVars {
        bool collateralReserveActive;
        bool collateralReservePaused;
        bool principalReserveActive;
        bool principalReservePaused;
        bool isCollateralEnabled;
    }

    /**
     * @notice Validates the liquidation action.
     * @param userConfig The user configuration mapping
     * @param collateralReserve The reserve data of the collateral
     * @param params Additional parameters needed for the validation
     */
    function validateLiquidationCall(
        DataTypes.UserConfigurationMap storage userConfig,
        DataTypes.ReserveData storage collateralReserve,
        DataTypes.ValidateLiquidationCallParams memory params
    ) internal view {
        ValidateLiquidationCallLocalVars memory vars;

        (vars.collateralReserveActive,,,, vars.collateralReservePaused) = collateralReserve.configuration.getFlags();

        (vars.principalReserveActive,,,, vars.principalReservePaused) =
            params.debtReserveCache.reserveConfiguration.getFlags();

        require(vars.collateralReserveActive && vars.principalReserveActive, Errors.RESERVE_INACTIVE);
        require(!vars.collateralReservePaused && !vars.principalReservePaused, Errors.RESERVE_PAUSED);

        require(
            params.priceOracleSentinel == address(0)
                || params.healthFactor < MINIMUM_HEALTH_FACTOR_LIQUIDATION_THRESHOLD
                || IPriceOracleSentinel(params.priceOracleSentinel).isLiquidationAllowed(),
            Errors.PRICE_ORACLE_SENTINEL_CHECK_FAILED
        );

        require(params.healthFactor < HEALTH_FACTOR_LIQUIDATION_THRESHOLD, Errors.HEALTH_FACTOR_NOT_BELOW_THRESHOLD);

        vars.isCollateralEnabled = collateralReserve.configuration.getLiquidationThreshold() != 0
            && userConfig.isUsingAsCollateral(collateralReserve.id);

        //if collateral isn't enabled as collateral by user, it cannot be liquidated
        require(vars.isCollateralEnabled, Errors.COLLATERAL_CANNOT_BE_LIQUIDATED);
        require(params.totalDebt != 0, Errors.SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER);
    }

    /**
     * @notice Validates the health factor of a user.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param userConfig The state of the user for the specific reserve
     * @param user The user to validate health factor of
     * @param userEModeCategory The users active efficiency mode category
     * @param reservesCount The number of available reserves
     * @param oracle The price oracle
     */
    function validateHealthFactor(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.UserConfigurationMap memory userConfig,
        address user,
        uint8 userEModeCategory,
        uint256 reservesCount,
        address oracle
    ) internal view returns (uint256, bool) {
        (,,,, uint256 healthFactor, bool hasZeroLtvCollateral) = GenericLogic.calculateUserAccountData(
            reservesData,
            reservesList,
            eModeCategories,
            DataTypes.CalculateUserAccountDataParams({
                userConfig: userConfig,
                reservesCount: reservesCount,
                user: user,
                oracle: oracle,
                userEModeCategory: userEModeCategory
            })
        );

        require(
            healthFactor >= HEALTH_FACTOR_LIQUIDATION_THRESHOLD, Errors.HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD
        );

        return (healthFactor, hasZeroLtvCollateral);
    }

    /**
     * @notice Validates the health factor of a user and the ltv of the asset being withdrawn.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param userConfig The state of the user for the specific reserve
     * @param asset The asset for which the ltv will be validated
     * @param from The user from which the aTokens are being transferred
     * @param reservesCount The number of available reserves
     * @param oracle The price oracle
     * @param userEModeCategory The users active efficiency mode category
     */
    function validateHFAndLtv(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.UserConfigurationMap memory userConfig,
        address asset,
        address from,
        uint256 reservesCount,
        address oracle,
        uint8 userEModeCategory
    ) internal view {
        DataTypes.ReserveData memory reserve = reservesData[asset];

        (, bool hasZeroLtvCollateral) = validateHealthFactor(
            reservesData, reservesList, eModeCategories, userConfig, from, userEModeCategory, reservesCount, oracle
        );

        require(!hasZeroLtvCollateral || reserve.configuration.getLtv() == 0, Errors.LTV_VALIDATION_FAILED);
    }

    /**
     * @notice Validates a transfer action.
     * @param reserve The reserve object
     */
    function validateTransfer(DataTypes.ReserveData storage reserve) internal view {
        require(!reserve.configuration.getPaused(), Errors.RESERVE_PAUSED);
    }

    /**
     * @notice Validates a drop reserve action.
     * @param reservesList The addresses of all the active reserves
     * @param reserve The reserve object
     * @param asset The address of the reserve's underlying asset
     */
    function validateDropReserve(
        mapping(uint256 => address) storage reservesList,
        DataTypes.ReserveData storage reserve,
        address asset
    ) internal view {
        require(asset != address(0), Errors.ZERO_ADDRESS_NOT_VALID);
        require(reserve.id != 0 || reservesList[0] == asset, Errors.ASSET_NOT_LISTED);
        require(IERC20(reserve.stableDebtTokenAddress).totalSupply() == 0, Errors.STABLE_DEBT_NOT_ZERO);
        require(IERC20(reserve.variableDebtTokenAddress).totalSupply() == 0, Errors.VARIABLE_DEBT_SUPPLY_NOT_ZERO);
        require(
            IERC20(reserve.aTokenAddress).totalSupply() == 0 && reserve.accruedToTreasury == 0,
            Errors.UNDERLYING_CLAIMABLE_RIGHTS_NOT_ZERO
        );
    }

    /**
     * @notice Validates the action of setting efficiency mode.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories a mapping storing configurations for all efficiency mode categories
     * @param userConfig the user configuration
     * @param reservesCount The total number of valid reserves
     * @param categoryId The id of the category
     */
    function validateSetUserEMode(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.UserConfigurationMap memory userConfig,
        uint256 reservesCount,
        uint8 categoryId
    ) internal view {
        // category is invalid if the liq threshold is not set
        require(
            categoryId == 0 || eModeCategories[categoryId].liquidationThreshold != 0, Errors.INCONSISTENT_EMODE_CATEGORY
        );

        // eMode can always be enabled if the user hasn't supplied anything
        if (userConfig.isEmpty()) {
            return;
        }

        // if user is trying to set another category than default we require that
        // either the user is not borrowing, or it's borrowing assets of categoryId
        if (categoryId != 0) {
            unchecked {
                for (uint256 i = 0; i < reservesCount; i++) {
                    if (userConfig.isBorrowing(i)) {
                        DataTypes.ReserveConfigurationMap memory configuration =
                        reservesData[reservesList[i]].configuration;
                        require(configuration.getEModeCategory() == categoryId, Errors.INCONSISTENT_EMODE_CATEGORY);
                    }
                }
            }
        }
    }

    /**
     * @notice Validates the action of activating the asset as collateral.
     * @dev Only possible if the asset has non-zero LTV and the user is not in isolation mode
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param userConfig the user configuration
     * @param reserveConfig The reserve configuration
     * @return True if the asset can be activated as collateral, false otherwise
     */
    function validateUseAsCollateral(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        DataTypes.UserConfigurationMap storage userConfig,
        DataTypes.ReserveConfigurationMap memory reserveConfig
    ) internal view returns (bool) {
        if (reserveConfig.getLtv() == 0) {
            return false;
        }
        if (!userConfig.isUsingAsCollateralAny()) {
            return true;
        }
        (bool isolationModeActive,,) = userConfig.getIsolationModeState(reservesData, reservesList);

        return (!isolationModeActive && reserveConfig.getDebtCeiling() == 0);
    }

    /**
     * @notice Validates if an asset should be automatically activated as collateral in the following actions: supply,
     * transfer, mint unbacked, and liquidate
     * @dev This is used to ensure that isolated assets are not enabled as collateral automatically
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param userConfig the user configuration
     * @param reserveConfig The reserve configuration
     * @return True if the asset can be activated as collateral, false otherwise
     */
    function validateAutomaticUseAsCollateral(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        DataTypes.UserConfigurationMap storage userConfig,
        DataTypes.ReserveConfigurationMap memory reserveConfig,
        address aTokenAddress
    ) internal view returns (bool) {
        if (reserveConfig.getDebtCeiling() != 0) {
            // ensures only the ISOLATED_COLLATERAL_SUPPLIER_ROLE can enable collateral as side-effect of an action
            IPoolAddressesProvider addressesProvider = IncentivizedERC20(aTokenAddress).POOL().ADDRESSES_PROVIDER();
            if (!IAccessControl(addressesProvider.getACLManager())
                    .hasRole(ISOLATED_COLLATERAL_SUPPLIER_ROLE, msg.sender)) return false;
        }
        return validateUseAsCollateral(reservesData, reservesList, userConfig, reserveConfig);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {IScaledBalanceToken} from "../../../interfaces/IScaledBalanceToken.sol";
import {IPriceOracleGetter} from "../../../interfaces/IPriceOracleGetter.sol";
import {ReserveConfiguration} from "../configuration/ReserveConfiguration.sol";
import {UserConfiguration} from "../configuration/UserConfiguration.sol";
import {PercentageMath} from "../math/PercentageMath.sol";
import {WadRayMath} from "../math/WadRayMath.sol";
import {DataTypes} from "../types/DataTypes.sol";
import {ReserveLogic} from "./ReserveLogic.sol";
import {EModeLogic} from "./EModeLogic.sol";

/**
 * @title GenericLogic library
 * @author Aave
 * @notice Implements protocol-level logic to calculate and validate the state of a user
 */
library GenericLogic {
    using ReserveLogic for DataTypes.ReserveData;
    using WadRayMath for uint256;
    using PercentageMath for uint256;
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
    using UserConfiguration for DataTypes.UserConfigurationMap;

    struct CalculateUserAccountDataVars {
        uint256 assetPrice;
        uint256 assetUnit;
        uint256 userBalanceInBaseCurrency;
        uint256 decimals;
        uint256 ltv;
        uint256 liquidationThreshold;
        uint256 i;
        uint256 healthFactor;
        uint256 totalCollateralInBaseCurrency;
        uint256 totalDebtInBaseCurrency;
        uint256 avgLtv;
        uint256 avgLiquidationThreshold;
        uint256 eModeAssetPrice;
        uint256 eModeLtv;
        uint256 eModeLiqThreshold;
        uint256 eModeAssetCategory;
        address currentReserveAddress;
        bool hasZeroLtvCollateral;
        bool isInEModeCategory;
    }

    /**
     * @notice Calculates the user data across the reserves.
     * @dev It includes the total liquidity/collateral/borrow balances in the base currency used by the price feed,
     * the average Loan To Value, the average Liquidation Ratio, and the Health factor.
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param params Additional parameters needed for the calculation
     * @return The total collateral of the user in the base currency used by the price feed
     * @return The total debt of the user in the base currency used by the price feed
     * @return The average ltv of the user
     * @return The average liquidation threshold of the user
     * @return The health factor of the user
     * @return True if the ltv is zero, false otherwise
     */
    function calculateUserAccountData(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        DataTypes.CalculateUserAccountDataParams memory params
    ) internal view returns (uint256, uint256, uint256, uint256, uint256, bool) {
        if (params.userConfig.isEmpty()) {
            return (0, 0, 0, 0, type(uint256).max, false);
        }

        CalculateUserAccountDataVars memory vars;

        if (params.userEModeCategory != 0) {
            (vars.eModeLtv, vars.eModeLiqThreshold, vars.eModeAssetPrice) = EModeLogic.getEModeConfiguration(
                eModeCategories[params.userEModeCategory], IPriceOracleGetter(params.oracle)
            );
        }

        while (vars.i < params.reservesCount) {
            if (!params.userConfig.isUsingAsCollateralOrBorrowing(vars.i)) {
                unchecked {
                    ++vars.i;
                }
                continue;
            }

            vars.currentReserveAddress = reservesList[vars.i];

            if (vars.currentReserveAddress == address(0)) {
                unchecked {
                    ++vars.i;
                }
                continue;
            }

            DataTypes.ReserveData storage currentReserve = reservesData[vars.currentReserveAddress];

            (vars.ltv, vars.liquidationThreshold,, vars.decimals,, vars.eModeAssetCategory) =
                currentReserve.configuration.getParams();

            unchecked {
                vars.assetUnit = 10 ** vars.decimals;
            }

            vars.assetPrice = vars.eModeAssetPrice != 0 && params.userEModeCategory == vars.eModeAssetCategory
                ? vars.eModeAssetPrice
                : IPriceOracleGetter(params.oracle).getAssetPrice(vars.currentReserveAddress);

            if (vars.liquidationThreshold != 0 && params.userConfig.isUsingAsCollateral(vars.i)) {
                vars.userBalanceInBaseCurrency =
                    _getUserBalanceInBaseCurrency(params.user, currentReserve, vars.assetPrice, vars.assetUnit);

                vars.totalCollateralInBaseCurrency += vars.userBalanceInBaseCurrency;

                vars.isInEModeCategory = EModeLogic.isInEModeCategory(params.userEModeCategory, vars.eModeAssetCategory);

                if (vars.ltv != 0) {
                    vars.avgLtv += vars.userBalanceInBaseCurrency * (vars.isInEModeCategory ? vars.eModeLtv : vars.ltv);
                } else {
                    vars.hasZeroLtvCollateral = true;
                }

                vars.avgLiquidationThreshold += vars.userBalanceInBaseCurrency
                * (vars.isInEModeCategory ? vars.eModeLiqThreshold : vars.liquidationThreshold);
            }

            if (params.userConfig.isBorrowing(vars.i)) {
                vars.totalDebtInBaseCurrency += _getUserDebtInBaseCurrency(
                    params.user, currentReserve, vars.assetPrice, vars.assetUnit
                );
            }

            unchecked {
                ++vars.i;
            }
        }

        unchecked {
            vars.avgLtv = vars.totalCollateralInBaseCurrency != 0 ? vars.avgLtv / vars.totalCollateralInBaseCurrency : 0;
            vars.avgLiquidationThreshold = vars.totalCollateralInBaseCurrency != 0
                ? vars.avgLiquidationThreshold / vars.totalCollateralInBaseCurrency
                : 0;
        }

        vars.healthFactor = (vars.totalDebtInBaseCurrency == 0)
            ? type(uint256).max
            : (vars.totalCollateralInBaseCurrency.percentMul(vars.avgLiquidationThreshold))
            .wadDiv(vars.totalDebtInBaseCurrency);
        return (
            vars.totalCollateralInBaseCurrency,
            vars.totalDebtInBaseCurrency,
            vars.avgLtv,
            vars.avgLiquidationThreshold,
            vars.healthFactor,
            vars.hasZeroLtvCollateral
        );
    }

    /**
     * @notice Calculates the maximum amount that can be borrowed depending on the available collateral, the total debt
     * and the average Loan To Value
     * @param totalCollateralInBaseCurrency The total collateral in the base currency used by the price feed
     * @param totalDebtInBaseCurrency The total borrow balance in the base currency used by the price feed
     * @param ltv The average loan to value
     * @return The amount available to borrow in the base currency of the used by the price feed
     */
    function calculateAvailableBorrows(
        uint256 totalCollateralInBaseCurrency,
        uint256 totalDebtInBaseCurrency,
        uint256 ltv
    ) internal pure returns (uint256) {
        uint256 availableBorrowsInBaseCurrency = totalCollateralInBaseCurrency.percentMul(ltv);

        if (availableBorrowsInBaseCurrency < totalDebtInBaseCurrency) {
            return 0;
        }

        availableBorrowsInBaseCurrency = availableBorrowsInBaseCurrency - totalDebtInBaseCurrency;
        return availableBorrowsInBaseCurrency;
    }

    /**
     * @notice Calculates total debt of the user in the based currency used to normalize the values of the assets
     * @dev This fetches the `balanceOf` of the stable and variable debt tokens for the user. For gas reasons, the
     * variable debt balance is calculated by fetching `scaledBalancesOf` normalized debt, which is cheaper than
     * fetching `balanceOf`
     * @param user The address of the user
     * @param reserve The data of the reserve for which the total debt of the user is being calculated
     * @param assetPrice The price of the asset for which the total debt of the user is being calculated
     * @param assetUnit The value representing one full unit of the asset (10^decimals)
     * @return The total debt of the user normalized to the base currency
     */
    function _getUserDebtInBaseCurrency(
        address user,
        DataTypes.ReserveData storage reserve,
        uint256 assetPrice,
        uint256 assetUnit
    ) private view returns (uint256) {
        // fetching variable debt
        uint256 userTotalDebt = IScaledBalanceToken(reserve.variableDebtTokenAddress).scaledBalanceOf(user);
        if (userTotalDebt != 0) {
            userTotalDebt = userTotalDebt.rayMul(reserve.getNormalizedDebt());
        }

        userTotalDebt = userTotalDebt + IERC20(reserve.stableDebtTokenAddress).balanceOf(user);

        userTotalDebt = assetPrice * userTotalDebt;

        unchecked {
            return userTotalDebt / assetUnit;
        }
    }

    /**
     * @notice Calculates total aToken balance of the user in the based currency used by the price oracle
     * @dev For gas reasons, the aToken balance is calculated by fetching `scaledBalancesOf` normalized debt, which
     * is cheaper than fetching `balanceOf`
     * @param user The address of the user
     * @param reserve The data of the reserve for which the total aToken balance of the user is being calculated
     * @param assetPrice The price of the asset for which the total aToken balance of the user is being calculated
     * @param assetUnit The value representing one full unit of the asset (10^decimals)
     * @return The total aToken balance of the user normalized to the base currency of the price oracle
     */
    function _getUserBalanceInBaseCurrency(
        address user,
        DataTypes.ReserveData storage reserve,
        uint256 assetPrice,
        uint256 assetUnit
    ) private view returns (uint256) {
        uint256 normalizedIncome = reserve.getNormalizedIncome();
        uint256 balance =
            (IScaledBalanceToken(reserve.aTokenAddress).scaledBalanceOf(user).rayMul(normalizedIncome)) * assetPrice;

        unchecked {
            return balance / assetUnit;
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {DataTypes} from "../types/DataTypes.sol";
import {ReserveConfiguration} from "../configuration/ReserveConfiguration.sol";
import {UserConfiguration} from "../configuration/UserConfiguration.sol";
import {SafeCast} from "../../../dependencies/openzeppelin/contracts/SafeCast.sol";

/**
 * @title IsolationModeLogic library
 * @author Aave
 * @notice Implements the base logic for handling repayments for assets borrowed in isolation mode
 */
library IsolationModeLogic {
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;
    using UserConfiguration for DataTypes.UserConfigurationMap;
    using SafeCast for uint256;

    // See `IPool` for descriptions
    event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);

    /**
     * @notice updated the isolated debt whenever a position collateralized by an isolated asset is repaid or liquidated
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param userConfig The user configuration mapping
     * @param reserveCache The cached data of the reserve
     * @param repayAmount The amount being repaid
     */
    function updateIsolatedDebtIfIsolated(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        DataTypes.UserConfigurationMap storage userConfig,
        DataTypes.ReserveCache memory reserveCache,
        uint256 repayAmount
    ) internal {
        (bool isolationModeActive, address isolationModeCollateralAddress,) =
            userConfig.getIsolationModeState(reservesData, reservesList);

        if (isolationModeActive) {
            uint128 isolationModeTotalDebt = reservesData[isolationModeCollateralAddress].isolationModeTotalDebt;

            uint128 isolatedDebtRepaid = (repayAmount / 10
                    ** (reserveCache.reserveConfiguration.getDecimals() - ReserveConfiguration.DEBT_CEILING_DECIMALS))
            .toUint128();

            // since the debt ceiling does not take into account the interest accrued, it might happen that amount
            // repaid > debt in isolation mode
            if (isolationModeTotalDebt <= isolatedDebtRepaid) {
                reservesData[isolationModeCollateralAddress].isolationModeTotalDebt = 0;
                emit IsolationModeTotalDebtUpdated(isolationModeCollateralAddress, 0);
            } else {
                uint256 nextIsolationModeTotalDebt = reservesData[isolationModeCollateralAddress]
                    .isolationModeTotalDebt = isolationModeTotalDebt - isolatedDebtRepaid;
                emit IsolationModeTotalDebtUpdated(isolationModeCollateralAddress, nextIsolationModeTotalDebt);
            }
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {GPv2SafeERC20} from "../../../dependencies/gnosis/contracts/GPv2SafeERC20.sol";
import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {IPriceOracleGetter} from "../../../interfaces/IPriceOracleGetter.sol";
import {UserConfiguration} from "../configuration/UserConfiguration.sol";
import {Errors} from "../helpers/Errors.sol";
import {WadRayMath} from "../math/WadRayMath.sol";
import {PercentageMath} from "../math/PercentageMath.sol";
import {DataTypes} from "../types/DataTypes.sol";
import {ValidationLogic} from "./ValidationLogic.sol";
import {ReserveLogic} from "./ReserveLogic.sol";

/**
 * @title EModeLogic library
 * @author Aave
 * @notice Implements the base logic for all the actions related to the eMode
 */
library EModeLogic {
    using ReserveLogic for DataTypes.ReserveCache;
    using ReserveLogic for DataTypes.ReserveData;
    using GPv2SafeERC20 for IERC20;
    using UserConfiguration for DataTypes.UserConfigurationMap;
    using WadRayMath for uint256;
    using PercentageMath for uint256;

    // See `IPool` for descriptions
    event UserEModeSet(address indexed user, uint8 categoryId);

    /**
     * @notice Updates the user efficiency mode category
     * @dev Will revert if user is borrowing non-compatible asset or change will drop HF < HEALTH_FACTOR_LIQUIDATION_THRESHOLD
     * @dev Emits the `UserEModeSet` event
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @param eModeCategories The configuration of all the efficiency mode categories
     * @param usersEModeCategory The state of all users efficiency mode category
     * @param userConfig The user configuration mapping that tracks the supplied/borrowed assets
     * @param params The additional parameters needed to execute the setUserEMode function
     */
    function executeSetUserEMode(
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList,
        mapping(uint8 => DataTypes.EModeCategory) storage eModeCategories,
        mapping(address => uint8) storage usersEModeCategory,
        DataTypes.UserConfigurationMap storage userConfig,
        DataTypes.ExecuteSetUserEModeParams memory params
    ) external {
        ValidationLogic.validateSetUserEMode(
            reservesData, reservesList, eModeCategories, userConfig, params.reservesCount, params.categoryId
        );

        uint8 prevCategoryId = usersEModeCategory[msg.sender];
        usersEModeCategory[msg.sender] = params.categoryId;

        if (prevCategoryId != 0) {
            ValidationLogic.validateHealthFactor(
                reservesData,
                reservesList,
                eModeCategories,
                userConfig,
                msg.sender,
                params.categoryId,
                params.reservesCount,
                params.oracle
            );
        }
        emit UserEModeSet(msg.sender, params.categoryId);
    }

    /**
     * @notice Gets the eMode configuration and calculates the eMode asset price if a custom oracle is configured
     * @dev The eMode asset price returned is 0 if no oracle is specified
     * @param category The user eMode category
     * @param oracle The price oracle
     * @return The eMode ltv
     * @return The eMode liquidation threshold
     * @return The eMode asset price
     */
    function getEModeConfiguration(DataTypes.EModeCategory storage category, IPriceOracleGetter oracle)
        internal
        view
        returns (uint256, uint256, uint256)
    {
        uint256 eModeAssetPrice = 0;
        address eModePriceSource = category.priceSource;

        if (eModePriceSource != address(0)) {
            eModeAssetPrice = oracle.getAssetPrice(eModePriceSource);
        }

        return (category.ltv, category.liquidationThreshold, eModeAssetPrice);
    }

    /**
     * @notice Checks if eMode is active for a user and if yes, if the asset belongs to the eMode category chosen
     * @param eModeUserCategory The user eMode category
     * @param eModeAssetCategory The asset eMode category
     * @return True if eMode is active and the asset belongs to the eMode category chosen by the user, false otherwise
     */
    function isInEModeCategory(uint256 eModeUserCategory, uint256 eModeAssetCategory) internal pure returns (bool) {
        return (eModeUserCategory != 0 && eModeAssetCategory == eModeUserCategory);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import {Errors} from "../helpers/Errors.sol";
import {DataTypes} from "../types/DataTypes.sol";
import {ReserveConfiguration} from "./ReserveConfiguration.sol";

/**
 * @title UserConfiguration library
 * @author Aave
 * @notice Implements the bitmap logic to handle the user configuration
 */
library UserConfiguration {
    using ReserveConfiguration for DataTypes.ReserveConfigurationMap;

    uint256 internal constant BORROWING_MASK = 0x5555555555555555555555555555555555555555555555555555555555555555;
    uint256 internal constant COLLATERAL_MASK = 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA;

    /**
     * @notice Sets if the user is borrowing the reserve identified by reserveIndex
     * @param self The configuration object
     * @param reserveIndex The index of the reserve in the bitmap
     * @param borrowing True if the user is borrowing the reserve, false otherwise
     */
    function setBorrowing(DataTypes.UserConfigurationMap storage self, uint256 reserveIndex, bool borrowing) internal {
        unchecked {
            require(reserveIndex < ReserveConfiguration.MAX_RESERVES_COUNT, Errors.INVALID_RESERVE_INDEX);
            uint256 bit = 1 << (reserveIndex << 1);
            if (borrowing) {
                self.data |= bit;
            } else {
                self.data &= ~bit;
            }
        }
    }

    /**
     * @notice Sets if the user is using as collateral the reserve identified by reserveIndex
     * @param self The configuration object
     * @param reserveIndex The index of the reserve in the bitmap
     * @param usingAsCollateral True if the user is using the reserve as collateral, false otherwise
     */
    function setUsingAsCollateral(
        DataTypes.UserConfigurationMap storage self,
        uint256 reserveIndex,
        bool usingAsCollateral
    ) internal {
        unchecked {
            require(reserveIndex < ReserveConfiguration.MAX_RESERVES_COUNT, Errors.INVALID_RESERVE_INDEX);
            uint256 bit = 1 << ((reserveIndex << 1) + 1);
            if (usingAsCollateral) {
                self.data |= bit;
            } else {
                self.data &= ~bit;
            }
        }
    }

    /**
     * @notice Returns if a user has been using the reserve for borrowing or as collateral
     * @param self The configuration object
     * @param reserveIndex The index of the reserve in the bitmap
     * @return True if the user has been using a reserve for borrowing or as collateral, false otherwise
     */
    function isUsingAsCollateralOrBorrowing(DataTypes.UserConfigurationMap memory self, uint256 reserveIndex)
        internal
        pure
        returns (bool)
    {
        unchecked {
            require(reserveIndex < ReserveConfiguration.MAX_RESERVES_COUNT, Errors.INVALID_RESERVE_INDEX);
            return (self.data >> (reserveIndex << 1)) & 3 != 0;
        }
    }

    /**
     * @notice Validate a user has been using the reserve for borrowing
     * @param self The configuration object
     * @param reserveIndex The index of the reserve in the bitmap
     * @return True if the user has been using a reserve for borrowing, false otherwise
     */
    function isBorrowing(DataTypes.UserConfigurationMap memory self, uint256 reserveIndex)
        internal
        pure
        returns (bool)
    {
        unchecked {
            require(reserveIndex < ReserveConfiguration.MAX_RESERVES_COUNT, Errors.INVALID_RESERVE_INDEX);
            return (self.data >> (reserveIndex << 1)) & 1 != 0;
        }
    }

    /**
     * @notice Validate a user has been using the reserve as collateral
     * @param self The configuration object
     * @param reserveIndex The index of the reserve in the bitmap
     * @return True if the user has been using a reserve as collateral, false otherwise
     */
    function isUsingAsCollateral(DataTypes.UserConfigurationMap memory self, uint256 reserveIndex)
        internal
        pure
        returns (bool)
    {
        unchecked {
            require(reserveIndex < ReserveConfiguration.MAX_RESERVES_COUNT, Errors.INVALID_RESERVE_INDEX);
            return (self.data >> ((reserveIndex << 1) + 1)) & 1 != 0;
        }
    }

    /**
     * @notice Checks if a user has been supplying only one reserve as collateral
     * @dev this uses a simple trick - if a number is a power of two (only one bit set) then n & (n - 1) == 0
     * @param self The configuration object
     * @return True if the user has been supplying as collateral one reserve, false otherwise
     */
    function isUsingAsCollateralOne(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) {
        uint256 collateralData = self.data & COLLATERAL_MASK;
        return collateralData != 0 && (collateralData & (collateralData - 1) == 0);
    }

    /**
     * @notice Checks if a user has been supplying any reserve as collateral
     * @param self The configuration object
     * @return True if the user has been supplying as collateral any reserve, false otherwise
     */
    function isUsingAsCollateralAny(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) {
        return self.data & COLLATERAL_MASK != 0;
    }

    /**
     * @notice Checks if a user has been borrowing only one asset
     * @dev this uses a simple trick - if a number is a power of two (only one bit set) then n & (n - 1) == 0
     * @param self The configuration object
     * @return True if the user has been supplying as collateral one reserve, false otherwise
     */
    function isBorrowingOne(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) {
        uint256 borrowingData = self.data & BORROWING_MASK;
        return borrowingData != 0 && (borrowingData & (borrowingData - 1) == 0);
    }

    /**
     * @notice Checks if a user has been borrowing from any reserve
     * @param self The configuration object
     * @return True if the user has been borrowing any reserve, false otherwise
     */
    function isBorrowingAny(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) {
        return self.data & BORROWING_MASK != 0;
    }

    /**
     * @notice Checks if a user has not been using any reserve for borrowing or supply
     * @param self The configuration object
     * @return True if the user has not been borrowing or supplying any reserve, false otherwise
     */
    function isEmpty(DataTypes.UserConfigurationMap memory self) internal pure returns (bool) {
        return self.data == 0;
    }

    /**
     * @notice Returns the Isolation Mode state of the user
     * @param self The configuration object
     * @param reservesData The state of all the reserves
     * @param reservesList The addresses of all the active reserves
     * @return True if the user is in isolation mode, false otherwise
     * @return The address of the only asset used as collateral
     * @return The debt ceiling of the reserve
     */
    function getIsolationModeState(
        DataTypes.UserConfigurationMap memory self,
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList
    ) internal view returns (bool, address, uint256) {
        if (isUsingAsCollateralOne(self)) {
            uint256 assetId = _getFirstAssetIdByMask(self, COLLATERAL_MASK);

            address assetAddress = reservesList[assetId];
            uint256 ceiling = reservesData[assetAddress].configuration.getDebtCeiling();
            if (ceiling != 0) {
                return (true, assetAddress, ceiling);
            }
        }
        return (false, address(0), 0);
    }

    /**
     * @notice Returns the siloed borrowing state for the user
     * @param self The configuration object
     * @param reservesData The data of all the reserves
     * @param reservesList The reserve list
     * @return True if the user has borrowed a siloed asset, false otherwise
     * @return The address of the only borrowed asset
     */
    function getSiloedBorrowingState(
        DataTypes.UserConfigurationMap memory self,
        mapping(address => DataTypes.ReserveData) storage reservesData,
        mapping(uint256 => address) storage reservesList
    ) internal view returns (bool, address) {
        if (isBorrowingOne(self)) {
            uint256 assetId = _getFirstAssetIdByMask(self, BORROWING_MASK);
            address assetAddress = reservesList[assetId];
            if (reservesData[assetAddress].configuration.getSiloedBorrowing()) {
                return (true, assetAddress);
            }
        }

        return (false, address(0));
    }

    /**
     * @notice Returns the address of the first asset flagged in the bitmap given the corresponding bitmask
     * @param self The configuration object
     * @return The index of the first asset flagged in the bitmap once the corresponding mask is applied
     */
    function _getFirstAssetIdByMask(DataTypes.UserConfigurationMap memory self, uint256 mask)
        internal
        pure
        returns (uint256)
    {
        unchecked {
            uint256 bitmapData = self.data & mask;
            uint256 firstAssetPosition = bitmapData & ~(bitmapData - 1);
            uint256 id;

            while ((firstAssetPosition >>= 2) != 0) {
                id += 1;
            }
            return id;
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import {Errors} from "../helpers/Errors.sol";
import {DataTypes} from "../types/DataTypes.sol";

/**
 * @title ReserveConfiguration library
 * @author Aave
 * @notice Implements the bitmap logic to handle the reserve configuration
 */
library ReserveConfiguration {
    uint256 internal constant LTV_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000; // prettier-ignore
    uint256 internal constant LIQUIDATION_THRESHOLD_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFF; // prettier-ignore
    uint256 internal constant LIQUIDATION_BONUS_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFF; // prettier-ignore
    uint256 internal constant DECIMALS_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant ACTIVE_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant FROZEN_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant BORROWING_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant STABLE_BORROWING_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant PAUSED_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant BORROWABLE_IN_ISOLATION_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant SILOED_BORROWING_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant FLASHLOAN_ENABLED_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant RESERVE_FACTOR_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant BORROW_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant SUPPLY_CAP_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant LIQUIDATION_PROTOCOL_FEE_MASK =
        0xFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant EMODE_CATEGORY_MASK = 0xFFFFFFFFFFFFFFFFFFFF00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant UNBACKED_MINT_CAP_MASK =
        0xFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
    uint256 internal constant DEBT_CEILING_MASK = 0xF0000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore

    /// @dev For the LTV, the start bit is 0 (up to 15), hence no bitshifting is needed
    uint256 internal constant LIQUIDATION_THRESHOLD_START_BIT_POSITION = 16;
    uint256 internal constant LIQUIDATION_BONUS_START_BIT_POSITION = 32;
    uint256 internal constant RESERVE_DECIMALS_START_BIT_POSITION = 48;
    uint256 internal constant IS_ACTIVE_START_BIT_POSITION = 56;
    uint256 internal constant IS_FROZEN_START_BIT_POSITION = 57;
    uint256 internal constant BORROWING_ENABLED_START_BIT_POSITION = 58;
    uint256 internal constant STABLE_BORROWING_ENABLED_START_BIT_POSITION = 59;
    uint256 internal constant IS_PAUSED_START_BIT_POSITION = 60;
    uint256 internal constant BORROWABLE_IN_ISOLATION_START_BIT_POSITION = 61;
    uint256 internal constant SILOED_BORROWING_START_BIT_POSITION = 62;
    uint256 internal constant FLASHLOAN_ENABLED_START_BIT_POSITION = 63;
    uint256 internal constant RESERVE_FACTOR_START_BIT_POSITION = 64;
    uint256 internal constant BORROW_CAP_START_BIT_POSITION = 80;
    uint256 internal constant SUPPLY_CAP_START_BIT_POSITION = 116;
    uint256 internal constant LIQUIDATION_PROTOCOL_FEE_START_BIT_POSITION = 152;
    uint256 internal constant EMODE_CATEGORY_START_BIT_POSITION = 168;
    uint256 internal constant UNBACKED_MINT_CAP_START_BIT_POSITION = 176;
    uint256 internal constant DEBT_CEILING_START_BIT_POSITION = 212;

    uint256 internal constant MAX_VALID_LTV = 65535;
    uint256 internal constant MAX_VALID_LIQUIDATION_THRESHOLD = 65535;
    uint256 internal constant MAX_VALID_LIQUIDATION_BONUS = 65535;
    uint256 internal constant MAX_VALID_DECIMALS = 255;
    uint256 internal constant MAX_VALID_RESERVE_FACTOR = 65535;
    uint256 internal constant MAX_VALID_BORROW_CAP = 68719476735;
    uint256 internal constant MAX_VALID_SUPPLY_CAP = 68719476735;
    uint256 internal constant MAX_VALID_LIQUIDATION_PROTOCOL_FEE = 65535;
    uint256 internal constant MAX_VALID_EMODE_CATEGORY = 255;
    uint256 internal constant MAX_VALID_UNBACKED_MINT_CAP = 68719476735;
    uint256 internal constant MAX_VALID_DEBT_CEILING = 1099511627775;

    uint256 public constant DEBT_CEILING_DECIMALS = 2;
    uint16 public constant MAX_RESERVES_COUNT = 128;

    /**
     * @notice Sets the Loan to Value of the reserve
     * @param self The reserve configuration
     * @param ltv The new ltv
     */
    function setLtv(DataTypes.ReserveConfigurationMap memory self, uint256 ltv) internal pure {
        require(ltv <= MAX_VALID_LTV, Errors.INVALID_LTV);

        self.data = (self.data & LTV_MASK) | ltv;
    }

    /**
     * @notice Gets the Loan to Value of the reserve
     * @param self The reserve configuration
     * @return The loan to value
     */
    function getLtv(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return self.data & ~LTV_MASK;
    }

    /**
     * @notice Sets the liquidation threshold of the reserve
     * @param self The reserve configuration
     * @param threshold The new liquidation threshold
     */
    function setLiquidationThreshold(DataTypes.ReserveConfigurationMap memory self, uint256 threshold) internal pure {
        require(threshold <= MAX_VALID_LIQUIDATION_THRESHOLD, Errors.INVALID_LIQ_THRESHOLD);

        self.data = (self.data & LIQUIDATION_THRESHOLD_MASK) | (threshold << LIQUIDATION_THRESHOLD_START_BIT_POSITION);
    }

    /**
     * @notice Gets the liquidation threshold of the reserve
     * @param self The reserve configuration
     * @return The liquidation threshold
     */
    function getLiquidationThreshold(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION;
    }

    /**
     * @notice Sets the liquidation bonus of the reserve
     * @param self The reserve configuration
     * @param bonus The new liquidation bonus
     */
    function setLiquidationBonus(DataTypes.ReserveConfigurationMap memory self, uint256 bonus) internal pure {
        require(bonus <= MAX_VALID_LIQUIDATION_BONUS, Errors.INVALID_LIQ_BONUS);

        self.data = (self.data & LIQUIDATION_BONUS_MASK) | (bonus << LIQUIDATION_BONUS_START_BIT_POSITION);
    }

    /**
     * @notice Gets the liquidation bonus of the reserve
     * @param self The reserve configuration
     * @return The liquidation bonus
     */
    function getLiquidationBonus(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~LIQUIDATION_BONUS_MASK) >> LIQUIDATION_BONUS_START_BIT_POSITION;
    }

    /**
     * @notice Sets the decimals of the underlying asset of the reserve
     * @param self The reserve configuration
     * @param decimals The decimals
     */
    function setDecimals(DataTypes.ReserveConfigurationMap memory self, uint256 decimals) internal pure {
        require(decimals <= MAX_VALID_DECIMALS, Errors.INVALID_DECIMALS);

        self.data = (self.data & DECIMALS_MASK) | (decimals << RESERVE_DECIMALS_START_BIT_POSITION);
    }

    /**
     * @notice Gets the decimals of the underlying asset of the reserve
     * @param self The reserve configuration
     * @return The decimals of the asset
     */
    function getDecimals(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION;
    }

    /**
     * @notice Sets the active state of the reserve
     * @param self The reserve configuration
     * @param active The active state
     */
    function setActive(DataTypes.ReserveConfigurationMap memory self, bool active) internal pure {
        self.data = (self.data & ACTIVE_MASK) | (uint256(active ? 1 : 0) << IS_ACTIVE_START_BIT_POSITION);
    }

    /**
     * @notice Gets the active state of the reserve
     * @param self The reserve configuration
     * @return The active state
     */
    function getActive(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~ACTIVE_MASK) != 0;
    }

    /**
     * @notice Sets the frozen state of the reserve
     * @param self The reserve configuration
     * @param frozen The frozen state
     */
    function setFrozen(DataTypes.ReserveConfigurationMap memory self, bool frozen) internal pure {
        self.data = (self.data & FROZEN_MASK) | (uint256(frozen ? 1 : 0) << IS_FROZEN_START_BIT_POSITION);
    }

    /**
     * @notice Gets the frozen state of the reserve
     * @param self The reserve configuration
     * @return The frozen state
     */
    function getFrozen(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~FROZEN_MASK) != 0;
    }

    /**
     * @notice Sets the paused state of the reserve
     * @param self The reserve configuration
     * @param paused The paused state
     */
    function setPaused(DataTypes.ReserveConfigurationMap memory self, bool paused) internal pure {
        self.data = (self.data & PAUSED_MASK) | (uint256(paused ? 1 : 0) << IS_PAUSED_START_BIT_POSITION);
    }

    /**
     * @notice Gets the paused state of the reserve
     * @param self The reserve configuration
     * @return The paused state
     */
    function getPaused(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~PAUSED_MASK) != 0;
    }

    /**
     * @notice Sets the borrowable in isolation flag for the reserve.
     * @dev When this flag is set to true, the asset will be borrowable against isolated collaterals and the borrowed
     * amount will be accumulated in the isolated collateral's total debt exposure.
     * @dev Only assets of the same family (eg USD stablecoins) should be borrowable in isolation mode to keep
     * consistency in the debt ceiling calculations.
     * @param self The reserve configuration
     * @param borrowable True if the asset is borrowable
     */
    function setBorrowableInIsolation(DataTypes.ReserveConfigurationMap memory self, bool borrowable) internal pure {
        self.data = (self.data & BORROWABLE_IN_ISOLATION_MASK)
            | (uint256(borrowable ? 1 : 0) << BORROWABLE_IN_ISOLATION_START_BIT_POSITION);
    }

    /**
     * @notice Gets the borrowable in isolation flag for the reserve.
     * @dev If the returned flag is true, the asset is borrowable against isolated collateral. Assets borrowed with
     * isolated collateral is accounted for in the isolated collateral's total debt exposure.
     * @dev Only assets of the same family (eg USD stablecoins) should be borrowable in isolation mode to keep
     * consistency in the debt ceiling calculations.
     * @param self The reserve configuration
     * @return The borrowable in isolation flag
     */
    function getBorrowableInIsolation(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~BORROWABLE_IN_ISOLATION_MASK) != 0;
    }

    /**
     * @notice Sets the siloed borrowing flag for the reserve.
     * @dev When this flag is set to true, users borrowing this asset will not be allowed to borrow any other asset.
     * @param self The reserve configuration
     * @param siloed True if the asset is siloed
     */
    function setSiloedBorrowing(DataTypes.ReserveConfigurationMap memory self, bool siloed) internal pure {
        self.data =
            (self.data & SILOED_BORROWING_MASK) | (uint256(siloed ? 1 : 0) << SILOED_BORROWING_START_BIT_POSITION);
    }

    /**
     * @notice Gets the siloed borrowing flag for the reserve.
     * @dev When this flag is set to true, users borrowing this asset will not be allowed to borrow any other asset.
     * @param self The reserve configuration
     * @return The siloed borrowing flag
     */
    function getSiloedBorrowing(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~SILOED_BORROWING_MASK) != 0;
    }

    /**
     * @notice Enables or disables borrowing on the reserve
     * @param self The reserve configuration
     * @param enabled True if the borrowing needs to be enabled, false otherwise
     */
    function setBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled) internal pure {
        self.data = (self.data & BORROWING_MASK) | (uint256(enabled ? 1 : 0) << BORROWING_ENABLED_START_BIT_POSITION);
    }

    /**
     * @notice Gets the borrowing state of the reserve
     * @param self The reserve configuration
     * @return The borrowing state
     */
    function getBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~BORROWING_MASK) != 0;
    }

    /**
     * @notice Enables or disables stable rate borrowing on the reserve
     * @param self The reserve configuration
     * @param enabled True if the stable rate borrowing needs to be enabled, false otherwise
     */
    function setStableRateBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self, bool enabled) internal pure {
        self.data = (self.data & STABLE_BORROWING_MASK)
            | (uint256(enabled ? 1 : 0) << STABLE_BORROWING_ENABLED_START_BIT_POSITION);
    }

    /**
     * @notice Gets the stable rate borrowing state of the reserve
     * @param self The reserve configuration
     * @return The stable rate borrowing state
     */
    function getStableRateBorrowingEnabled(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~STABLE_BORROWING_MASK) != 0;
    }

    /**
     * @notice Sets the reserve factor of the reserve
     * @param self The reserve configuration
     * @param reserveFactor The reserve factor
     */
    function setReserveFactor(DataTypes.ReserveConfigurationMap memory self, uint256 reserveFactor) internal pure {
        require(reserveFactor <= MAX_VALID_RESERVE_FACTOR, Errors.INVALID_RESERVE_FACTOR);

        self.data = (self.data & RESERVE_FACTOR_MASK) | (reserveFactor << RESERVE_FACTOR_START_BIT_POSITION);
    }

    /**
     * @notice Gets the reserve factor of the reserve
     * @param self The reserve configuration
     * @return The reserve factor
     */
    function getReserveFactor(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION;
    }

    /**
     * @notice Sets the borrow cap of the reserve
     * @param self The reserve configuration
     * @param borrowCap The borrow cap
     */
    function setBorrowCap(DataTypes.ReserveConfigurationMap memory self, uint256 borrowCap) internal pure {
        require(borrowCap <= MAX_VALID_BORROW_CAP, Errors.INVALID_BORROW_CAP);

        self.data = (self.data & BORROW_CAP_MASK) | (borrowCap << BORROW_CAP_START_BIT_POSITION);
    }

    /**
     * @notice Gets the borrow cap of the reserve
     * @param self The reserve configuration
     * @return The borrow cap
     */
    function getBorrowCap(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION;
    }

    /**
     * @notice Sets the supply cap of the reserve
     * @param self The reserve configuration
     * @param supplyCap The supply cap
     */
    function setSupplyCap(DataTypes.ReserveConfigurationMap memory self, uint256 supplyCap) internal pure {
        require(supplyCap <= MAX_VALID_SUPPLY_CAP, Errors.INVALID_SUPPLY_CAP);

        self.data = (self.data & SUPPLY_CAP_MASK) | (supplyCap << SUPPLY_CAP_START_BIT_POSITION);
    }

    /**
     * @notice Gets the supply cap of the reserve
     * @param self The reserve configuration
     * @return The supply cap
     */
    function getSupplyCap(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~SUPPLY_CAP_MASK) >> SUPPLY_CAP_START_BIT_POSITION;
    }

    /**
     * @notice Sets the debt ceiling in isolation mode for the asset
     * @param self The reserve configuration
     * @param ceiling The maximum debt ceiling for the asset
     */
    function setDebtCeiling(DataTypes.ReserveConfigurationMap memory self, uint256 ceiling) internal pure {
        require(ceiling <= MAX_VALID_DEBT_CEILING, Errors.INVALID_DEBT_CEILING);

        self.data = (self.data & DEBT_CEILING_MASK) | (ceiling << DEBT_CEILING_START_BIT_POSITION);
    }

    /**
     * @notice Gets the debt ceiling for the asset if the asset is in isolation mode
     * @param self The reserve configuration
     * @return The debt ceiling (0 = isolation mode disabled)
     */
    function getDebtCeiling(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~DEBT_CEILING_MASK) >> DEBT_CEILING_START_BIT_POSITION;
    }

    /**
     * @notice Sets the liquidation protocol fee of the reserve
     * @param self The reserve configuration
     * @param liquidationProtocolFee The liquidation protocol fee
     */
    function setLiquidationProtocolFee(DataTypes.ReserveConfigurationMap memory self, uint256 liquidationProtocolFee)
        internal
        pure
    {
        require(liquidationProtocolFee <= MAX_VALID_LIQUIDATION_PROTOCOL_FEE, Errors.INVALID_LIQUIDATION_PROTOCOL_FEE);

        self.data = (self.data & LIQUIDATION_PROTOCOL_FEE_MASK)
            | (liquidationProtocolFee << LIQUIDATION_PROTOCOL_FEE_START_BIT_POSITION);
    }

    /**
     * @dev Gets the liquidation protocol fee
     * @param self The reserve configuration
     * @return The liquidation protocol fee
     */
    function getLiquidationProtocolFee(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~LIQUIDATION_PROTOCOL_FEE_MASK) >> LIQUIDATION_PROTOCOL_FEE_START_BIT_POSITION;
    }

    /**
     * @notice Sets the unbacked mint cap of the reserve
     * @param self The reserve configuration
     * @param unbackedMintCap The unbacked mint cap
     */
    function setUnbackedMintCap(DataTypes.ReserveConfigurationMap memory self, uint256 unbackedMintCap) internal pure {
        require(unbackedMintCap <= MAX_VALID_UNBACKED_MINT_CAP, Errors.INVALID_UNBACKED_MINT_CAP);

        self.data = (self.data & UNBACKED_MINT_CAP_MASK) | (unbackedMintCap << UNBACKED_MINT_CAP_START_BIT_POSITION);
    }

    /**
     * @dev Gets the unbacked mint cap of the reserve
     * @param self The reserve configuration
     * @return The unbacked mint cap
     */
    function getUnbackedMintCap(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~UNBACKED_MINT_CAP_MASK) >> UNBACKED_MINT_CAP_START_BIT_POSITION;
    }

    /**
     * @notice Sets the eMode asset category
     * @param self The reserve configuration
     * @param category The asset category when the user selects the eMode
     */
    function setEModeCategory(DataTypes.ReserveConfigurationMap memory self, uint256 category) internal pure {
        require(category <= MAX_VALID_EMODE_CATEGORY, Errors.INVALID_EMODE_CATEGORY);

        self.data = (self.data & EMODE_CATEGORY_MASK) | (category << EMODE_CATEGORY_START_BIT_POSITION);
    }

    /**
     * @dev Gets the eMode asset category
     * @param self The reserve configuration
     * @return The eMode category for the asset
     */
    function getEModeCategory(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256) {
        return (self.data & ~EMODE_CATEGORY_MASK) >> EMODE_CATEGORY_START_BIT_POSITION;
    }

    /**
     * @notice Sets the flashloanable flag for the reserve
     * @param self The reserve configuration
     * @param flashLoanEnabled True if the asset is flashloanable, false otherwise
     */
    function setFlashLoanEnabled(DataTypes.ReserveConfigurationMap memory self, bool flashLoanEnabled) internal pure {
        self.data = (self.data & FLASHLOAN_ENABLED_MASK)
            | (uint256(flashLoanEnabled ? 1 : 0) << FLASHLOAN_ENABLED_START_BIT_POSITION);
    }

    /**
     * @notice Gets the flashloanable flag for the reserve
     * @param self The reserve configuration
     * @return The flashloanable flag
     */
    function getFlashLoanEnabled(DataTypes.ReserveConfigurationMap memory self) internal pure returns (bool) {
        return (self.data & ~FLASHLOAN_ENABLED_MASK) != 0;
    }

    /**
     * @notice Gets the configuration flags of the reserve
     * @param self The reserve configuration
     * @return The state flag representing active
     * @return The state flag representing frozen
     * @return The state flag representing borrowing enabled
     * @return The state flag representing stableRateBorrowing enabled
     * @return The state flag representing paused
     */
    function getFlags(DataTypes.ReserveConfigurationMap memory self)
        internal
        pure
        returns (bool, bool, bool, bool, bool)
    {
        uint256 dataLocal = self.data;

        return (
            (dataLocal & ~ACTIVE_MASK) != 0,
            (dataLocal & ~FROZEN_MASK) != 0,
            (dataLocal & ~BORROWING_MASK) != 0,
            (dataLocal & ~STABLE_BORROWING_MASK) != 0,
            (dataLocal & ~PAUSED_MASK) != 0
        );
    }

    /**
     * @notice Gets the configuration parameters of the reserve from storage
     * @param self The reserve configuration
     * @return The state param representing ltv
     * @return The state param representing liquidation threshold
     * @return The state param representing liquidation bonus
     * @return The state param representing reserve decimals
     * @return The state param representing reserve factor
     * @return The state param representing eMode category
     */
    function getParams(DataTypes.ReserveConfigurationMap memory self)
        internal
        pure
        returns (uint256, uint256, uint256, uint256, uint256, uint256)
    {
        uint256 dataLocal = self.data;

        return (
            dataLocal & ~LTV_MASK,
            (dataLocal & ~LIQUIDATION_THRESHOLD_MASK) >> LIQUIDATION_THRESHOLD_START_BIT_POSITION,
            (dataLocal & ~LIQUIDATION_BONUS_MASK) >> LIQUIDATION_BONUS_START_BIT_POSITION,
            (dataLocal & ~DECIMALS_MASK) >> RESERVE_DECIMALS_START_BIT_POSITION,
            (dataLocal & ~RESERVE_FACTOR_MASK) >> RESERVE_FACTOR_START_BIT_POSITION,
            (dataLocal & ~EMODE_CATEGORY_MASK) >> EMODE_CATEGORY_START_BIT_POSITION
        );
    }

    /**
     * @notice Gets the caps parameters of the reserve from storage
     * @param self The reserve configuration
     * @return The state param representing borrow cap
     * @return The state param representing supply cap.
     */
    function getCaps(DataTypes.ReserveConfigurationMap memory self) internal pure returns (uint256, uint256) {
        uint256 dataLocal = self.data;

        return (
            (dataLocal & ~BORROW_CAP_MASK) >> BORROW_CAP_START_BIT_POSITION,
            (dataLocal & ~SUPPLY_CAP_MASK) >> SUPPLY_CAP_START_BIT_POSITION
        );
    }
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IERC20} from "../dependencies/openzeppelin/contracts/IERC20.sol";
import {IScaledBalanceToken} from "./IScaledBalanceToken.sol";
import {IInitializableAToken} from "./IInitializableAToken.sol";

/**
 * @title IAToken
 * @author Aave
 * @notice Defines the basic interface for an AToken.
 */
interface IAToken is IERC20, IScaledBalanceToken, IInitializableAToken {
    /**
     * @dev Emitted during the transfer action
     * @param from The user whose tokens are being transferred
     * @param to The recipient
     * @param value The scaled amount being transferred
     * @param index The next liquidity index of the reserve
     */
    event BalanceTransfer(address indexed from, address indexed to, uint256 value, uint256 index);

    /**
     * @notice Mints `amount` aTokens to `user`
     * @param caller The address performing the mint
     * @param onBehalfOf The address of the user that will receive the minted aTokens
     * @param amount The amount of tokens getting minted
     * @param index The next liquidity index of the reserve
     * @return `true` if the the previous balance of the user was 0
     */
    function mint(address caller, address onBehalfOf, uint256 amount, uint256 index) external returns (bool);

    /**
     * @notice Burns aTokens from `user` and sends the equivalent amount of underlying to `receiverOfUnderlying`
     * @dev In some instances, the mint event could be emitted from a burn transaction
     * if the amount to burn is less than the interest that the user accrued
     * @param from The address from which the aTokens will be burned
     * @param receiverOfUnderlying The address that will receive the underlying
     * @param amount The amount being burned
     * @param index The next liquidity index of the reserve
     */
    function burn(address from, address receiverOfUnderlying, uint256 amount, uint256 index) external;

    /**
     * @notice Mints aTokens to the reserve treasury
     * @param amount The amount of tokens getting minted
     * @param index The next liquidity index of the reserve
     */
    function mintToTreasury(uint256 amount, uint256 index) external;

    /**
     * @notice Transfers aTokens in the event of a borrow being liquidated, in case the liquidators reclaims the aToken
     * @param from The address getting liquidated, current owner of the aTokens
     * @param to The recipient
     * @param value The amount of tokens getting transferred
     */
    function transferOnLiquidation(address from, address to, uint256 value) external;

    /**
     * @notice Transfers the underlying asset to `target`.
     * @dev Used by the Pool to transfer assets in borrow(), withdraw() and flashLoan()
     * @param target The recipient of the underlying
     * @param amount The amount getting transferred
     */
    function transferUnderlyingTo(address target, uint256 amount) external;

    /**
     * @notice Handles the underlying received by the aToken after the transfer has been completed.
     * @dev The default implementation is empty as with standard ERC20 tokens, nothing needs to be done after the
     * transfer is concluded. However in the future there may be aTokens that allow for example to stake the underlying
     * to receive LM rewards. In that case, `handleRepayment()` would perform the staking of the underlying asset.
     * @param user The user executing the repayment
     * @param onBehalfOf The address of the user who will get his debt reduced/removed
     * @param amount The amount getting repaid
     */
    function handleRepayment(address user, address onBehalfOf, uint256 amount) external;

    /**
     * @notice Allow passing a signed message to approve spending
     * @dev implements the permit function as for
     * https://github.com/ethereum/EIPs/blob/8a34d644aacf0f9f8f00815307fd7dd5da07655f/EIPS/eip-2612.md
     * @param owner The owner of the funds
     * @param spender The spender
     * @param value The amount
     * @param deadline The deadline timestamp, type(uint256).max for max deadline
     * @param v Signature param
     * @param s Signature param
     * @param r Signature param
     */
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
        external;

    /**
     * @notice Returns the address of the underlying asset of this aToken (E.g. WETH for aWETH)
     * @return The address of the underlying asset
     */
    function UNDERLYING_ASSET_ADDRESS() external view returns (address);

    /**
     * @notice Returns the address of the Aave treasury, receiving the fees on this aToken.
     * @return Address of the Aave treasury
     */
    function RESERVE_TREASURY_ADDRESS() external view returns (address);

    /**
     * @notice Get the domain separator for the token
     * @dev Return cached value if chainId matches cache, otherwise recomputes separator
     * @return The domain separator of the token at current chain
     */
    function DOMAIN_SEPARATOR() external view returns (bytes32);

    /**
     * @notice Returns the nonce for owner.
     * @param owner The address of the owner
     * @return The nonce of the owner
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @notice Rescue and transfer tokens locked in this contract
     * @param token The address of the token
     * @param to The address of the recipient
     * @param amount The amount of token to transfer
     */
    function rescueTokens(address token, address to, uint256 amount) external;
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IInitializableDebtToken} from "./IInitializableDebtToken.sol";

/**
 * @title IStableDebtToken
 * @author Aave
 * @notice Defines the interface for the stable debt token
 * @dev It does not inherit from IERC20 to save in code size
 */
interface IStableDebtToken is IInitializableDebtToken {
    /**
     * @dev Emitted when new stable debt is minted
     * @param user The address of the user who triggered the minting
     * @param onBehalfOf The recipient of stable debt tokens
     * @param amount The amount minted (user entered amount + balance increase from interest)
     * @param currentBalance The balance of the user based on the previous balance and balance increase from interest
     * @param balanceIncrease The increase in balance since the last action of the user 'onBehalfOf'
     * @param newRate The rate of the debt after the minting
     * @param avgStableRate The next average stable rate after the minting
     * @param newTotalSupply The next total supply of the stable debt token after the action
     */
    event Mint(
        address indexed user,
        address indexed onBehalfOf,
        uint256 amount,
        uint256 currentBalance,
        uint256 balanceIncrease,
        uint256 newRate,
        uint256 avgStableRate,
        uint256 newTotalSupply
    );

    /**
     * @dev Emitted when new stable debt is burned
     * @param from The address from which the debt will be burned
     * @param amount The amount being burned (user entered amount - balance increase from interest)
     * @param currentBalance The balance of the user based on the previous balance and balance increase from interest
     * @param balanceIncrease The increase in balance since the last action of 'from'
     * @param avgStableRate The next average stable rate after the burning
     * @param newTotalSupply The next total supply of the stable debt token after the action
     */
    event Burn(
        address indexed from,
        uint256 amount,
        uint256 currentBalance,
        uint256 balanceIncrease,
        uint256 avgStableRate,
        uint256 newTotalSupply
    );

    /**
     * @notice Mints debt token to the `onBehalfOf` address.
     * @dev The resulting rate is the weighted average between the rate of the new debt
     * and the rate of the previous debt
     * @param user The address receiving the borrowed underlying, being the delegatee in case
     * of credit delegate, or same as `onBehalfOf` otherwise
     * @param onBehalfOf The address receiving the debt tokens
     * @param amount The amount of debt tokens to mint
     * @param rate The rate of the debt being minted
     * @return True if it is the first borrow, false otherwise
     * @return The total stable debt
     * @return The average stable borrow rate
     */
    function mint(address user, address onBehalfOf, uint256 amount, uint256 rate)
        external
        returns (bool, uint256, uint256);

    /**
     * @notice Burns debt of `user`
     * @dev The resulting rate is the weighted average between the rate of the new debt
     * and the rate of the previous debt
     * @dev In some instances, a burn transaction will emit a mint event
     * if the amount to burn is less than the interest the user earned
     * @param from The address from which the debt will be burned
     * @param amount The amount of debt tokens getting burned
     * @return The total stable debt
     * @return The average stable borrow rate
     */
    function burn(address from, uint256 amount) external returns (uint256, uint256);

    /**
     * @notice Returns the average rate of all the stable rate loans.
     * @return The average stable rate
     */
    function getAverageStableRate() external view returns (uint256);

    /**
     * @notice Returns the stable rate of the user debt
     * @param user The address of the user
     * @return The stable rate of the user
     */
    function getUserStableRate(address user) external view returns (uint256);

    /**
     * @notice Returns the timestamp of the last update of the user
     * @param user The address of the user
     * @return The timestamp
     */
    function getUserLastUpdated(address user) external view returns (uint40);

    /**
     * @notice Returns the principal, the total supply, the average stable rate and the timestamp for the last update
     * @return The principal
     * @return The total supply
     * @return The average stable rate
     * @return The timestamp of the last update
     */
    function getSupplyData() external view returns (uint256, uint256, uint256, uint40);

    /**
     * @notice Returns the timestamp of the last update of the total supply
     * @return The timestamp
     */
    function getTotalSupplyLastUpdated() external view returns (uint40);

    /**
     * @notice Returns the total supply and the average stable rate
     * @return The total supply
     * @return The average rate
     */
    function getTotalSupplyAndAvgRate() external view returns (uint256, uint256);

    /**
     * @notice Returns the principal debt balance of the user
     * @return The debt balance of the user since the last burn/mint action
     */
    function principalBalanceOf(address user) external view returns (uint256);

    /**
     * @notice Returns the address of the underlying asset of this stableDebtToken (E.g. WETH for stableDebtWETH)
     * @return The address of the underlying asset
     */
    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IScaledBalanceToken} from "./IScaledBalanceToken.sol";
import {IInitializableDebtToken} from "./IInitializableDebtToken.sol";

/**
 * @title IVariableDebtToken
 * @author Aave
 * @notice Defines the basic interface for a variable debt token.
 */
interface IVariableDebtToken is IScaledBalanceToken, IInitializableDebtToken {
    /**
     * @notice Mints debt token to the `onBehalfOf` address
     * @param user The address receiving the borrowed underlying, being the delegatee in case
     * of credit delegate, or same as `onBehalfOf` otherwise
     * @param onBehalfOf The address receiving the debt tokens
     * @param amount The amount of debt being minted
     * @param index The variable debt index of the reserve
     * @return True if the previous balance of the user is 0, false otherwise
     * @return The scaled total debt of the reserve
     */
    function mint(address user, address onBehalfOf, uint256 amount, uint256 index) external returns (bool, uint256);

    /**
     * @notice Burns user variable debt
     * @dev In some instances, a burn transaction will emit a mint event
     * if the amount to burn is less than the interest that the user accrued
     * @param from The address from which the debt will be burned
     * @param amount The amount getting burned
     * @param index The variable debt index of the reserve
     * @return The scaled total debt of the reserve
     */
    function burn(address from, uint256 amount, uint256 index) external returns (uint256);

    /**
     * @notice Returns the address of the underlying asset of this debtToken (E.g. WETH for variableDebtWETH)
     * @return The address of the underlying asset
     */
    function UNDERLYING_ASSET_ADDRESS() external view returns (address);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

/**
 * @title IPriceOracleGetter
 * @author Aave
 * @notice Interface for the Aave price oracle.
 */
interface IPriceOracleGetter {
    /**
     * @notice Returns the base currency address
     * @dev Address 0x0 is reserved for USD as base currency.
     * @return Returns the base currency address.
     */
    function BASE_CURRENCY() external view returns (address);

    /**
     * @notice Returns the base currency unit
     * @dev 1 ether for ETH, 1e8 for USD.
     * @return Returns the base currency unit.
     */
    function BASE_CURRENCY_UNIT() external view returns (uint256);

    /**
     * @notice Returns the asset price in the base currency
     * @param asset The address of the asset
     * @return The price of the asset
     */
    function getAssetPrice(address asset) external view returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {DataTypes} from "../protocol/libraries/types/DataTypes.sol";

/**
 * @title IReserveInterestRateStrategy
 * @author Aave
 * @notice Interface for the calculation of the interest rates
 */
interface IReserveInterestRateStrategy {
    /**
     * @notice Calculates the interest rates depending on the reserve's state and configurations
     * @param params The parameters needed to calculate interest rates
     * @return liquidityRate The liquidity rate expressed in rays
     * @return stableBorrowRate The stable borrow rate expressed in rays
     * @return variableBorrowRate The variable borrow rate expressed in rays
     */
    function calculateInterestRates(DataTypes.CalculateInterestRatesParams memory params)
        external
        view
        returns (uint256, uint256, uint256);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

import {WadRayMath} from "./WadRayMath.sol";

/**
 * @title MathUtils library
 * @author Aave
 * @notice Provides functions to perform linear and compounded interest calculations
 */
library MathUtils {
    using WadRayMath for uint256;

    /// @dev Ignoring leap years
    uint256 internal constant SECONDS_PER_YEAR = 365 days;

    /**
     * @dev Function to calculate the interest accumulated using a linear interest rate formula
     * @param rate The interest rate, in ray
     * @param lastUpdateTimestamp The timestamp of the last update of the interest
     * @return The interest rate linearly accumulated during the timeDelta, in ray
     */
    function calculateLinearInterest(uint256 rate, uint40 lastUpdateTimestamp) internal view returns (uint256) {
        //solium-disable-next-line
        uint256 result = rate * (block.timestamp - uint256(lastUpdateTimestamp));
        unchecked {
            result = result / SECONDS_PER_YEAR;
        }

        return WadRayMath.RAY + result;
    }

    /**
     * @dev Function to calculate the interest using a compounded interest rate formula
     * To avoid expensive exponentiation, the calculation is performed using a binomial approximation:
     *
     *  (1+x)^n = 1+n*x+[n/2*(n-1)]*x^2+[n/6*(n-1)*(n-2)*x^3...
     *
     * The approximation slightly underpays liquidity providers and undercharges borrowers, with the advantage of great
     * gas cost reductions. The whitepaper contains reference to the approximation and a table showing the margin of
     * error per different time periods
     *
     * @param rate The interest rate, in ray
     * @param lastUpdateTimestamp The timestamp of the last update of the interest
     * @return The interest rate compounded during the timeDelta, in ray
     */
    function calculateCompoundedInterest(uint256 rate, uint40 lastUpdateTimestamp, uint256 currentTimestamp)
        internal
        pure
        returns (uint256)
    {
        //solium-disable-next-line
        uint256 exp = currentTimestamp - uint256(lastUpdateTimestamp);

        if (exp == 0) {
            return WadRayMath.RAY;
        }

        uint256 expMinusOne;
        uint256 expMinusTwo;
        uint256 basePowerTwo;
        uint256 basePowerThree;
        unchecked {
            expMinusOne = exp - 1;

            expMinusTwo = exp > 2 ? exp - 2 : 0;

            basePowerTwo = rate.rayMul(rate) / (SECONDS_PER_YEAR * SECONDS_PER_YEAR);
            basePowerThree = basePowerTwo.rayMul(rate) / SECONDS_PER_YEAR;
        }

        uint256 secondTerm = exp * expMinusOne * basePowerTwo;
        unchecked {
            secondTerm /= 2;
        }
        uint256 thirdTerm = exp * expMinusOne * expMinusTwo * basePowerThree;
        unchecked {
            thirdTerm /= 6;
        }

        return WadRayMath.RAY + (rate * exp) / SECONDS_PER_YEAR + secondTerm + thirdTerm;
    }

    /**
     * @dev Calculates the compounded interest between the timestamp of the last update and the current block timestamp
     * @param rate The interest rate (in ray)
     * @param lastUpdateTimestamp The timestamp from which the interest accumulation needs to be calculated
     * @return The interest rate compounded between lastUpdateTimestamp and current block timestamp, in ray
     */
    function calculateCompoundedInterest(uint256 rate, uint40 lastUpdateTimestamp) internal view returns (uint256) {
        return calculateCompoundedInterest(rate, lastUpdateTimestamp, block.timestamp);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

/**
 * @title Errors library
 * @author Aave
 * @notice Defines the error messages emitted by the different contracts of the Aave protocol
 */
library Errors {
    string public constant CALLER_NOT_POOL_ADMIN = "1"; // 'The caller of the function is not a pool admin'
    string public constant CALLER_NOT_EMERGENCY_ADMIN = "2"; // 'The caller of the function is not an emergency admin'
    string public constant CALLER_NOT_POOL_OR_EMERGENCY_ADMIN = "3"; // 'The caller of the function is not a pool or emergency admin'
    string public constant CALLER_NOT_RISK_OR_POOL_ADMIN = "4"; // 'The caller of the function is not a risk or pool admin'
    string public constant CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN = "5"; // 'The caller of the function is not an asset listing or pool admin'
    string public constant CALLER_NOT_BRIDGE = "6"; // 'The caller of the function is not a bridge'
    string public constant ADDRESSES_PROVIDER_NOT_REGISTERED = "7"; // 'Pool addresses provider is not registered'
    string public constant INVALID_ADDRESSES_PROVIDER_ID = "8"; // 'Invalid id for the pool addresses provider'
    string public constant NOT_CONTRACT = "9"; // 'Address is not a contract'
    string public constant CALLER_NOT_POOL_CONFIGURATOR = "10"; // 'The caller of the function is not the pool configurator'
    string public constant CALLER_NOT_ATOKEN = "11"; // 'The caller of the function is not an AToken'
    string public constant INVALID_ADDRESSES_PROVIDER = "12"; // 'The address of the pool addresses provider is invalid'
    string public constant INVALID_FLASHLOAN_EXECUTOR_RETURN = "13"; // 'Invalid return value of the flashloan executor function'
    string public constant RESERVE_ALREADY_ADDED = "14"; // 'Reserve has already been added to reserve list'
    string public constant NO_MORE_RESERVES_ALLOWED = "15"; // 'Maximum amount of reserves in the pool reached'
    string public constant EMODE_CATEGORY_RESERVED = "16"; // 'Zero eMode category is reserved for volatile heterogeneous assets'
    string public constant INVALID_EMODE_CATEGORY_ASSIGNMENT = "17"; // 'Invalid eMode category assignment to asset'
    string public constant RESERVE_LIQUIDITY_NOT_ZERO = "18"; // 'The liquidity of the reserve needs to be 0'
    string public constant FLASHLOAN_PREMIUM_INVALID = "19"; // 'Invalid flashloan premium'
    string public constant INVALID_RESERVE_PARAMS = "20"; // 'Invalid risk parameters for the reserve'
    string public constant INVALID_EMODE_CATEGORY_PARAMS = "21"; // 'Invalid risk parameters for the eMode category'
    string public constant BRIDGE_PROTOCOL_FEE_INVALID = "22"; // 'Invalid bridge protocol fee'
    string public constant CALLER_MUST_BE_POOL = "23"; // 'The caller of this function must be a pool'
    string public constant INVALID_MINT_AMOUNT = "24"; // 'Invalid amount to mint'
    string public constant INVALID_BURN_AMOUNT = "25"; // 'Invalid amount to burn'
    string public constant INVALID_AMOUNT = "26"; // 'Amount must be greater than 0'
    string public constant RESERVE_INACTIVE = "27"; // 'Action requires an active reserve'
    string public constant RESERVE_FROZEN = "28"; // 'Action cannot be performed because the reserve is frozen'
    string public constant RESERVE_PAUSED = "29"; // 'Action cannot be performed because the reserve is paused'
    string public constant BORROWING_NOT_ENABLED = "30"; // 'Borrowing is not enabled'
    string public constant STABLE_BORROWING_NOT_ENABLED = "31"; // 'Stable borrowing is not enabled'
    string public constant NOT_ENOUGH_AVAILABLE_USER_BALANCE = "32"; // 'User cannot withdraw more than the available balance'
    string public constant INVALID_INTEREST_RATE_MODE_SELECTED = "33"; // 'Invalid interest rate mode selected'
    string public constant COLLATERAL_BALANCE_IS_ZERO = "34"; // 'The collateral balance is 0'
    string public constant HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "35"; // 'Health factor is lesser than the liquidation threshold'
    string public constant COLLATERAL_CANNOT_COVER_NEW_BORROW = "36"; // 'There is not enough collateral to cover a new borrow'
    string public constant COLLATERAL_SAME_AS_BORROWING_CURRENCY = "37"; // 'Collateral is (mostly) the same currency that is being borrowed'
    string public constant AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "38"; // 'The requested amount is greater than the max loan size in stable rate mode'
    string public constant NO_DEBT_OF_SELECTED_TYPE = "39"; // 'For repayment of a specific type of debt, the user needs to have debt that type'
    string public constant NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "40"; // 'To repay on behalf of a user an explicit amount to repay is needed'
    string public constant NO_OUTSTANDING_STABLE_DEBT = "41"; // 'User does not have outstanding stable rate debt on this reserve'
    string public constant NO_OUTSTANDING_VARIABLE_DEBT = "42"; // 'User does not have outstanding variable rate debt on this reserve'
    string public constant UNDERLYING_BALANCE_ZERO = "43"; // 'The underlying balance needs to be greater than 0'
    string public constant INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "44"; // 'Interest rate rebalance conditions were not met'
    string public constant HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "45"; // 'Health factor is not below the threshold'
    string public constant COLLATERAL_CANNOT_BE_LIQUIDATED = "46"; // 'The collateral chosen cannot be liquidated'
    string public constant SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "47"; // 'User did not borrow the specified currency'
    string public constant INCONSISTENT_FLASHLOAN_PARAMS = "49"; // 'Inconsistent flashloan parameters'
    string public constant BORROW_CAP_EXCEEDED = "50"; // 'Borrow cap is exceeded'
    string public constant SUPPLY_CAP_EXCEEDED = "51"; // 'Supply cap is exceeded'
    string public constant UNBACKED_MINT_CAP_EXCEEDED = "52"; // 'Unbacked mint cap is exceeded'
    string public constant DEBT_CEILING_EXCEEDED = "53"; // 'Debt ceiling is exceeded'
    string public constant UNDERLYING_CLAIMABLE_RIGHTS_NOT_ZERO = "54"; // 'Claimable rights over underlying not zero (aToken supply or accruedToTreasury)'
    string public constant STABLE_DEBT_NOT_ZERO = "55"; // 'Stable debt supply is not zero'
    string public constant VARIABLE_DEBT_SUPPLY_NOT_ZERO = "56"; // 'Variable debt supply is not zero'
    string public constant LTV_VALIDATION_FAILED = "57"; // 'Ltv validation failed'
    string public constant INCONSISTENT_EMODE_CATEGORY = "58"; // 'Inconsistent eMode category'
    string public constant PRICE_ORACLE_SENTINEL_CHECK_FAILED = "59"; // 'Price oracle sentinel validation failed'
    string public constant ASSET_NOT_BORROWABLE_IN_ISOLATION = "60"; // 'Asset is not borrowable in isolation mode'
    string public constant RESERVE_ALREADY_INITIALIZED = "61"; // 'Reserve has already been initialized'
    string public constant USER_IN_ISOLATION_MODE_OR_LTV_ZERO = "62"; // 'User is in isolation mode or ltv is zero'
    string public constant INVALID_LTV = "63"; // 'Invalid ltv parameter for the reserve'
    string public constant INVALID_LIQ_THRESHOLD = "64"; // 'Invalid liquidity threshold parameter for the reserve'
    string public constant INVALID_LIQ_BONUS = "65"; // 'Invalid liquidity bonus parameter for the reserve'
    string public constant INVALID_DECIMALS = "66"; // 'Invalid decimals parameter of the underlying asset of the reserve'
    string public constant INVALID_RESERVE_FACTOR = "67"; // 'Invalid reserve factor parameter for the reserve'
    string public constant INVALID_BORROW_CAP = "68"; // 'Invalid borrow cap for the reserve'
    string public constant INVALID_SUPPLY_CAP = "69"; // 'Invalid supply cap for the reserve'
    string public constant INVALID_LIQUIDATION_PROTOCOL_FEE = "70"; // 'Invalid liquidation protocol fee for the reserve'
    string public constant INVALID_EMODE_CATEGORY = "71"; // 'Invalid eMode category for the reserve'
    string public constant INVALID_UNBACKED_MINT_CAP = "72"; // 'Invalid unbacked mint cap for the reserve'
    string public constant INVALID_DEBT_CEILING = "73"; // 'Invalid debt ceiling for the reserve
    string public constant INVALID_RESERVE_INDEX = "74"; // 'Invalid reserve index'
    string public constant ACL_ADMIN_CANNOT_BE_ZERO = "75"; // 'ACL admin cannot be set to the zero address'
    string public constant INCONSISTENT_PARAMS_LENGTH = "76"; // 'Array parameters that should be equal length are not'
    string public constant ZERO_ADDRESS_NOT_VALID = "77"; // 'Zero address not valid'
    string public constant INVALID_EXPIRATION = "78"; // 'Invalid expiration'
    string public constant INVALID_SIGNATURE = "79"; // 'Invalid signature'
    string public constant OPERATION_NOT_SUPPORTED = "80"; // 'Operation not supported'
    string public constant DEBT_CEILING_NOT_ZERO = "81"; // 'Debt ceiling is not zero'
    string public constant ASSET_NOT_LISTED = "82"; // 'Asset is not listed'
    string public constant INVALID_OPTIMAL_USAGE_RATIO = "83"; // 'Invalid optimal usage ratio'
    string public constant INVALID_OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO = "84"; // 'Invalid optimal stable to total debt ratio'
    string public constant UNDERLYING_CANNOT_BE_RESCUED = "85"; // 'The underlying asset cannot be rescued'
    string public constant ADDRESSES_PROVIDER_ALREADY_ADDED = "86"; // 'Reserve has already been added to reserve list'
    string public constant POOL_ADDRESSES_DO_NOT_MATCH = "87"; // 'The token implementation pool address and the pool address provided by the initializing pool do not match'
    string public constant STABLE_BORROWING_ENABLED = "88"; // 'Stable borrowing is enabled'
    string public constant SILOED_BORROWING_VIOLATION = "89"; // 'User is trying to borrow multiple assets including a siloed one'
    string public constant RESERVE_DEBT_NOT_ZERO = "90"; // the total debt of the reserve needs to be 0
    string public constant FLASHLOAN_DISABLED = "91"; // FlashLoaning for this asset is disabled
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeCast.sol)
pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success,) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage)
        internal
        returns (bytes memory)
    {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage)
        internal
        returns (bytes memory)
    {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage)
        internal
        view
        returns (bytes memory)
    {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage)
        internal
        returns (bytes memory)
    {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage)
        internal
        pure
        returns (bytes memory)
    {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

/**
 * @title IScaledBalanceToken
 * @author Aave
 * @notice Defines the basic interface for a scaled-balance token.
 */
interface IScaledBalanceToken {
    /**
     * @dev Emitted after the mint action
     * @param caller The address performing the mint
     * @param onBehalfOf The address of the user that will receive the minted tokens
     * @param value The scaled-up amount being minted (based on user entered amount and balance increase from interest)
     * @param balanceIncrease The increase in scaled-up balance since the last action of 'onBehalfOf'
     * @param index The next liquidity index of the reserve
     */
    event Mint(
        address indexed caller, address indexed onBehalfOf, uint256 value, uint256 balanceIncrease, uint256 index
    );

    /**
     * @dev Emitted after the burn action
     * @dev If the burn function does not involve a transfer of the underlying asset, the target defaults to zero address
     * @param from The address from which the tokens will be burned
     * @param target The address that will receive the underlying, if any
     * @param value The scaled-up amount being burned (user entered amount - balance increase from interest)
     * @param balanceIncrease The increase in scaled-up balance since the last action of 'from'
     * @param index The next liquidity index of the reserve
     */
    event Burn(address indexed from, address indexed target, uint256 value, uint256 balanceIncrease, uint256 index);

    /**
     * @notice Returns the scaled balance of the user.
     * @dev The scaled balance is the sum of all the updated stored balance divided by the reserve's liquidity index
     * at the moment of the update
     * @param user The user whose balance is calculated
     * @return The scaled balance of the user
     */
    function scaledBalanceOf(address user) external view returns (uint256);

    /**
     * @notice Returns the scaled balance of the user and the scaled total supply.
     * @param user The address of the user
     * @return The scaled balance of the user
     * @return The scaled total supply
     */
    function getScaledUserBalanceAndSupply(address user) external view returns (uint256, uint256);

    /**
     * @notice Returns the scaled total supply of the scaled balance token. Represents sum(debt/index)
     * @return The scaled total supply
     */
    function scaledTotalSupply() external view returns (uint256);

    /**
     * @notice Returns last index interest was accrued to the user's balance
     * @param user The address of the user
     * @return The last index interest was accrued to the user's balance, expressed in ray
     */
    function getPreviousIndex(address user) external view returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol";

/**
 * @title IPriceOracleSentinel
 * @author Aave
 * @notice Defines the basic interface for the PriceOracleSentinel
 */
interface IPriceOracleSentinel {
    /**
     * @dev Emitted after the sequencer oracle is updated
     * @param newSequencerOracle The new sequencer oracle
     */
    event SequencerOracleUpdated(address newSequencerOracle);

    /**
     * @dev Emitted after the grace period is updated
     * @param newGracePeriod The new grace period value
     */
    event GracePeriodUpdated(uint256 newGracePeriod);

    /**
     * @notice Returns the PoolAddressesProvider
     * @return The address of the PoolAddressesProvider contract
     */
    function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);

    /**
     * @notice Returns true if the `borrow` operation is allowed.
     * @dev Operation not allowed when PriceOracle is down or grace period not passed.
     * @return True if the `borrow` operation is allowed, false otherwise.
     */
    function isBorrowAllowed() external view returns (bool);

    /**
     * @notice Returns true if the `liquidation` operation is allowed.
     * @dev Operation not allowed when PriceOracle is down or grace period not passed.
     * @return True if the `liquidation` operation is allowed, false otherwise.
     */
    function isLiquidationAllowed() external view returns (bool);

    /**
     * @notice Updates the address of the sequencer oracle
     * @param newSequencerOracle The address of the new Sequencer Oracle to use
     */
    function setSequencerOracle(address newSequencerOracle) external;

    /**
     * @notice Updates the duration of the grace period
     * @param newGracePeriod The value of the new grace period duration
     */
    function setGracePeriod(uint256 newGracePeriod) external;

    /**
     * @notice Returns the SequencerOracle
     * @return The address of the sequencer oracle contract
     */
    function getSequencerOracle() external view returns (address);

    /**
     * @notice Returns the grace period
     * @return The duration of the grace period
     */
    function getGracePeriod() external view returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

/**
 * @title IPoolAddressesProvider
 * @author Aave
 * @notice Defines the basic interface for a Pool Addresses Provider.
 */
interface IPoolAddressesProvider {
    /**
     * @dev Emitted when the market identifier is updated.
     * @param oldMarketId The old id of the market
     * @param newMarketId The new id of the market
     */
    event MarketIdSet(string indexed oldMarketId, string indexed newMarketId);

    /**
     * @dev Emitted when the pool is updated.
     * @param oldAddress The old address of the Pool
     * @param newAddress The new address of the Pool
     */
    event PoolUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the pool configurator is updated.
     * @param oldAddress The old address of the PoolConfigurator
     * @param newAddress The new address of the PoolConfigurator
     */
    event PoolConfiguratorUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the price oracle is updated.
     * @param oldAddress The old address of the PriceOracle
     * @param newAddress The new address of the PriceOracle
     */
    event PriceOracleUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the ACL manager is updated.
     * @param oldAddress The old address of the ACLManager
     * @param newAddress The new address of the ACLManager
     */
    event ACLManagerUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the ACL admin is updated.
     * @param oldAddress The old address of the ACLAdmin
     * @param newAddress The new address of the ACLAdmin
     */
    event ACLAdminUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the price oracle sentinel is updated.
     * @param oldAddress The old address of the PriceOracleSentinel
     * @param newAddress The new address of the PriceOracleSentinel
     */
    event PriceOracleSentinelUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the pool data provider is updated.
     * @param oldAddress The old address of the PoolDataProvider
     * @param newAddress The new address of the PoolDataProvider
     */
    event PoolDataProviderUpdated(address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when a new proxy is created.
     * @param id The identifier of the proxy
     * @param proxyAddress The address of the created proxy contract
     * @param implementationAddress The address of the implementation contract
     */
    event ProxyCreated(bytes32 indexed id, address indexed proxyAddress, address indexed implementationAddress);

    /**
     * @dev Emitted when a new non-proxied contract address is registered.
     * @param id The identifier of the contract
     * @param oldAddress The address of the old contract
     * @param newAddress The address of the new contract
     */
    event AddressSet(bytes32 indexed id, address indexed oldAddress, address indexed newAddress);

    /**
     * @dev Emitted when the implementation of the proxy registered with id is updated
     * @param id The identifier of the contract
     * @param proxyAddress The address of the proxy contract
     * @param oldImplementationAddress The address of the old implementation contract
     * @param newImplementationAddress The address of the new implementation contract
     */
    event AddressSetAsProxy(
        bytes32 indexed id,
        address indexed proxyAddress,
        address oldImplementationAddress,
        address indexed newImplementationAddress
    );

    /**
     * @notice Returns the id of the Aave market to which this contract points to.
     * @return The market id
     */
    function getMarketId() external view returns (string memory);

    /**
     * @notice Associates an id with a specific PoolAddressesProvider.
     * @dev This can be used to create an onchain registry of PoolAddressesProviders to
     * identify and validate multiple Aave markets.
     * @param newMarketId The market id
     */
    function setMarketId(string calldata newMarketId) external;

    /**
     * @notice Returns an address by its identifier.
     * @dev The returned address might be an EOA or a contract, potentially proxied
     * @dev It returns ZERO if there is no registered address with the given id
     * @param id The id
     * @return The address of the registered for the specified id
     */
    function getAddress(bytes32 id) external view returns (address);

    /**
     * @notice General function to update the implementation of a proxy registered with
     * certain `id`. If there is no proxy registered, it will instantiate one and
     * set as implementation the `newImplementationAddress`.
     * @dev IMPORTANT Use this function carefully, only for ids that don't have an explicit
     * setter function, in order to avoid unexpected consequences
     * @param id The id
     * @param newImplementationAddress The address of the new implementation
     */
    function setAddressAsProxy(bytes32 id, address newImplementationAddress) external;

    /**
     * @notice Sets an address for an id replacing the address saved in the addresses map.
     * @dev IMPORTANT Use this function carefully, as it will do a hard replacement
     * @param id The id
     * @param newAddress The address to set
     */
    function setAddress(bytes32 id, address newAddress) external;

    /**
     * @notice Returns the address of the Pool proxy.
     * @return The Pool proxy address
     */
    function getPool() external view returns (address);

    /**
     * @notice Updates the implementation of the Pool, or creates a proxy
     * setting the new `pool` implementation when the function is called for the first time.
     * @param newPoolImpl The new Pool implementation
     */
    function setPoolImpl(address newPoolImpl) external;

    /**
     * @notice Returns the address of the PoolConfigurator proxy.
     * @return The PoolConfigurator proxy address
     */
    function getPoolConfigurator() external view returns (address);

    /**
     * @notice Updates the implementation of the PoolConfigurator, or creates a proxy
     * setting the new `PoolConfigurator` implementation when the function is called for the first time.
     * @param newPoolConfiguratorImpl The new PoolConfigurator implementation
     */
    function setPoolConfiguratorImpl(address newPoolConfiguratorImpl) external;

    /**
     * @notice Returns the address of the price oracle.
     * @return The address of the PriceOracle
     */
    function getPriceOracle() external view returns (address);

    /**
     * @notice Updates the address of the price oracle.
     * @param newPriceOracle The address of the new PriceOracle
     */
    function setPriceOracle(address newPriceOracle) external;

    /**
     * @notice Returns the address of the ACL manager.
     * @return The address of the ACLManager
     */
    function getACLManager() external view returns (address);

    /**
     * @notice Updates the address of the ACL manager.
     * @param newAclManager The address of the new ACLManager
     */
    function setACLManager(address newAclManager) external;

    /**
     * @notice Returns the address of the ACL admin.
     * @return The address of the ACL admin
     */
    function getACLAdmin() external view returns (address);

    /**
     * @notice Updates the address of the ACL admin.
     * @param newAclAdmin The address of the new ACL admin
     */
    function setACLAdmin(address newAclAdmin) external;

    /**
     * @notice Returns the address of the price oracle sentinel.
     * @return The address of the PriceOracleSentinel
     */
    function getPriceOracleSentinel() external view returns (address);

    /**
     * @notice Updates the address of the price oracle sentinel.
     * @param newPriceOracleSentinel The address of the new PriceOracleSentinel
     */
    function setPriceOracleSentinel(address newPriceOracleSentinel) external;

    /**
     * @notice Returns the address of the data provider.
     * @return The address of the DataProvider
     */
    function getPoolDataProvider() external view returns (address);

    /**
     * @notice Updates the address of the data provider.
     * @param newDataProvider The address of the new DataProvider
     */
    function setPoolDataProvider(address newDataProvider) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;

import {Context} from "../../../dependencies/openzeppelin/contracts/Context.sol";
import {IERC20} from "../../../dependencies/openzeppelin/contracts/IERC20.sol";
import {IERC20Detailed} from "../../../dependencies/openzeppelin/contracts/IERC20Detailed.sol";
import {SafeCast} from "../../../dependencies/openzeppelin/contracts/SafeCast.sol";
import {WadRayMath} from "../../libraries/math/WadRayMath.sol";
import {Errors} from "../../libraries/helpers/Errors.sol";
import {IAaveIncentivesController} from "../../../interfaces/IAaveIncentivesController.sol";
import {IPoolAddressesProvider} from "../../../interfaces/IPoolAddressesProvider.sol";
import {IPool} from "../../../interfaces/IPool.sol";
import {IACLManager} from "../../../interfaces/IACLManager.sol";

/**
 * @title IncentivizedERC20
 * @author Aave, inspired by the Openzeppelin ERC20 implementation
 * @notice Basic ERC20 implementation
 */
abstract contract IncentivizedERC20 is Context, IERC20Detailed {
    using WadRayMath for uint256;
    using SafeCast for uint256;

    /**
     * @dev Only pool admin can call functions marked by this modifier.
     */
    modifier onlyPoolAdmin() {
        IACLManager aclManager = IACLManager(_addressesProvider.getACLManager());
        require(aclManager.isPoolAdmin(msg.sender), Errors.CALLER_NOT_POOL_ADMIN);
        _;
    }

    /**
     * @dev Only pool can call functions marked by this modifier.
     */
    modifier onlyPool() {
        require(_msgSender() == address(POOL), Errors.CALLER_MUST_BE_POOL);
        _;
    }

    /**
     * @dev UserState - additionalData is a flexible field.
     * ATokens and VariableDebtTokens use this field store the index of the
     * user's last supply/withdrawal/borrow/repayment. StableDebtTokens use
     * this field to store the user's stable rate.
     */
    struct UserState {
        uint128 balance;
        uint128 additionalData;
    }
    // Map of users address and their state data (userAddress => userStateData)
    mapping(address => UserState) internal _userState;

    // Map of allowances (delegator => delegatee => allowanceAmount)
    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 internal _totalSupply;
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    IAaveIncentivesController internal _incentivesController;
    IPoolAddressesProvider internal immutable _addressesProvider;
    IPool public immutable POOL;

    /**
     * @dev Constructor.
     * @param pool The reference to the main Pool contract
     * @param name The name of the token
     * @param symbol The symbol of the token
     * @param decimals The number of decimals of the token
     */
    constructor(IPool pool, string memory name, string memory symbol, uint8 decimals) {
        _addressesProvider = pool.ADDRESSES_PROVIDER();
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        POOL = pool;
    }

    /// @inheritdoc IERC20Detailed
    function name() public view override returns (string memory) {
        return _name;
    }

    /// @inheritdoc IERC20Detailed
    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    /// @inheritdoc IERC20Detailed
    function decimals() external view override returns (uint8) {
        return _decimals;
    }

    /// @inheritdoc IERC20
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /// @inheritdoc IERC20
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _userState[account].balance;
    }

    /**
     * @notice Returns the address of the Incentives Controller contract
     * @return The address of the Incentives Controller
     */
    function getIncentivesController() external view virtual returns (IAaveIncentivesController) {
        return _incentivesController;
    }

    /**
     * @notice Sets a new Incentives Controller
     * @param controller the new Incentives controller
     */
    function setIncentivesController(IAaveIncentivesController controller) external onlyPoolAdmin {
        _incentivesController = controller;
    }

    /// @inheritdoc IERC20
    function transfer(address recipient, uint256 amount) external virtual override returns (bool) {
        uint128 castAmount = amount.toUint128();
        _transfer(_msgSender(), recipient, castAmount);
        return true;
    }

    /// @inheritdoc IERC20
    function allowance(address owner, address spender) external view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /// @inheritdoc IERC20
    function approve(address spender, uint256 amount) external virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /// @inheritdoc IERC20
    function transferFrom(address sender, address recipient, uint256 amount) external virtual override returns (bool) {
        uint128 castAmount = amount.toUint128();
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - castAmount);
        _transfer(sender, recipient, castAmount);
        return true;
    }

    /**
     * @notice Increases the allowance of spender to spend _msgSender() tokens
     * @param spender The user allowed to spend on behalf of _msgSender()
     * @param addedValue The amount being added to the allowance
     * @return `true`
     */
    function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @notice Decreases the allowance of spender to spend _msgSender() tokens
     * @param spender The user allowed to spend on behalf of _msgSender()
     * @param subtractedValue The amount being subtracted to the allowance
     * @return `true`
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
        return true;
    }

    /**
     * @notice Transfers tokens between two users and apply incentives if defined.
     * @param sender The source address
     * @param recipient The destination address
     * @param amount The amount getting transferred
     */
    function _transfer(address sender, address recipient, uint128 amount) internal virtual {
        uint128 oldSenderBalance = _userState[sender].balance;
        _userState[sender].balance = oldSenderBalance - amount;
        uint128 oldRecipientBalance = _userState[recipient].balance;
        _userState[recipient].balance = oldRecipientBalance + amount;

        IAaveIncentivesController incentivesControllerLocal = _incentivesController;
        if (address(incentivesControllerLocal) != address(0)) {
            uint256 currentTotalSupply = _totalSupply;
            incentivesControllerLocal.handleAction(sender, currentTotalSupply, oldSenderBalance);
            if (sender != recipient) {
                incentivesControllerLocal.handleAction(recipient, currentTotalSupply, oldRecipientBalance);
            }
        }
    }

    /**
     * @notice Approve `spender` to use `amount` of `owner`s balance
     * @param owner The address owning the tokens
     * @param spender The address approved for spending
     * @param amount The amount of tokens to approve spending of
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @notice Update the name of the token
     * @param newName The new name for the token
     */
    function _setName(string memory newName) internal {
        _name = newName;
    }

    /**
     * @notice Update the symbol for the token
     * @param newSymbol The new symbol for the token
     */
    function _setSymbol(string memory newSymbol) internal {
        _symbol = newSymbol;
    }

    /**
     * @notice Update the number of decimals for the token
     * @param newDecimals The new number of decimals for the token
     */
    function _setDecimals(uint8 newDecimals) internal {
        _decimals = newDecimals;
    }
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IAaveIncentivesController} from "./IAaveIncentivesController.sol";
import {IPool} from "./IPool.sol";

/**
 * @title IInitializableAToken
 * @author Aave
 * @notice Interface for the initialize function on AToken
 */
interface IInitializableAToken {
    /**
     * @dev Emitted when an aToken is initialized
     * @param underlyingAsset The address of the underlying asset
     * @param pool The address of the associated pool
     * @param treasury The address of the treasury
     * @param incentivesController The address of the incentives controller for this aToken
     * @param aTokenDecimals The decimals of the underlying
     * @param aTokenName The name of the aToken
     * @param aTokenSymbol The symbol of the aToken
     * @param params A set of encoded parameters for additional initialization
     */
    event Initialized(
        address indexed underlyingAsset,
        address indexed pool,
        address treasury,
        address incentivesController,
        uint8 aTokenDecimals,
        string aTokenName,
        string aTokenSymbol,
        bytes params
    );

    /**
     * @notice Initializes the aToken
     * @param pool The pool contract that is initializing this contract
     * @param treasury The address of the Aave treasury, receiving the fees on this aToken
     * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
     * @param incentivesController The smart contract managing potential incentives distribution
     * @param aTokenDecimals The decimals of the aToken, same as the underlying asset's
     * @param aTokenName The name of the aToken
     * @param aTokenSymbol The symbol of the aToken
     * @param params A set of encoded parameters for additional initialization
     */
    function initialize(
        IPool pool,
        address treasury,
        address underlyingAsset,
        IAaveIncentivesController incentivesController,
        uint8 aTokenDecimals,
        string calldata aTokenName,
        string calldata aTokenSymbol,
        bytes calldata params
    ) external;
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IAaveIncentivesController} from "./IAaveIncentivesController.sol";
import {IPool} from "./IPool.sol";

/**
 * @title IInitializableDebtToken
 * @author Aave
 * @notice Interface for the initialize function common between debt tokens
 */
interface IInitializableDebtToken {
    /**
     * @dev Emitted when a debt token is initialized
     * @param underlyingAsset The address of the underlying asset
     * @param pool The address of the associated pool
     * @param incentivesController The address of the incentives controller for this aToken
     * @param debtTokenDecimals The decimals of the debt token
     * @param debtTokenName The name of the debt token
     * @param debtTokenSymbol The symbol of the debt token
     * @param params A set of encoded parameters for additional initialization
     */
    event Initialized(
        address indexed underlyingAsset,
        address indexed pool,
        address incentivesController,
        uint8 debtTokenDecimals,
        string debtTokenName,
        string debtTokenSymbol,
        bytes params
    );

    /**
     * @notice Initializes the debt token.
     * @param pool The pool contract that is initializing this contract
     * @param underlyingAsset The address of the underlying asset of this aToken (E.g. WETH for aWETH)
     * @param incentivesController The smart contract managing potential incentives distribution
     * @param debtTokenDecimals The decimals of the debtToken, same as the underlying asset's
     * @param debtTokenName The name of the token
     * @param debtTokenSymbol The symbol of the token
     * @param params A set of encoded parameters for additional initialization
     */
    function initialize(
        IPool pool,
        address underlyingAsset,
        IAaveIncentivesController incentivesController,
        uint8 debtTokenDecimals,
        string memory debtTokenName,
        string memory debtTokenSymbol,
        bytes calldata params
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IERC20} from "./IERC20.sol";

interface IERC20Detailed is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

/**
 * @title IAaveIncentivesController
 * @author Aave
 * @notice Defines the basic interface for an Aave Incentives Controller.
 * @dev It only contains one single function, needed as a hook on aToken and debtToken transfers.
 */
interface IAaveIncentivesController {
    /**
     * @dev Called by the corresponding asset on transfer hook in order to update the rewards distribution.
     * @dev The units of `totalSupply` and `userBalance` should be the same.
     * @param user The address of the user whose asset balance has changed
     * @param totalSupply The total supply of the asset prior to user balance change
     * @param userBalance The previous user balance prior to balance change
     */
    function handleAction(address user, uint256 totalSupply, uint256 userBalance) external;
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol";
import {DataTypes} from "../protocol/libraries/types/DataTypes.sol";

/**
 * @title IPool
 * @author Aave
 * @notice Defines the basic interface for an Aave Pool.
 */
interface IPool {
    /**
     * @dev Emitted on mintUnbacked()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address initiating the supply
     * @param onBehalfOf The beneficiary of the supplied assets, receiving the aTokens
     * @param amount The amount of supplied assets
     * @param referralCode The referral code used
     */
    event MintUnbacked(
        address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referralCode
    );

    /**
     * @dev Emitted on backUnbacked()
     * @param reserve The address of the underlying asset of the reserve
     * @param backer The address paying for the backing
     * @param amount The amount added as backing
     * @param fee The amount paid in fees
     */
    event BackUnbacked(address indexed reserve, address indexed backer, uint256 amount, uint256 fee);

    /**
     * @dev Emitted on supply()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address initiating the supply
     * @param onBehalfOf The beneficiary of the supply, receiving the aTokens
     * @param amount The amount supplied
     * @param referralCode The referral code used
     */
    event Supply(
        address indexed reserve, address user, address indexed onBehalfOf, uint256 amount, uint16 indexed referralCode
    );

    /**
     * @dev Emitted on withdraw()
     * @param reserve The address of the underlying asset being withdrawn
     * @param user The address initiating the withdrawal, owner of aTokens
     * @param to The address that will receive the underlying
     * @param amount The amount to be withdrawn
     */
    event Withdraw(address indexed reserve, address indexed user, address indexed to, uint256 amount);

    /**
     * @dev Emitted on borrow() and flashLoan() when debt needs to be opened
     * @param reserve The address of the underlying asset being borrowed
     * @param user The address of the user initiating the borrow(), receiving the funds on borrow() or just
     * initiator of the transaction on flashLoan()
     * @param onBehalfOf The address that will be getting the debt
     * @param amount The amount borrowed out
     * @param interestRateMode The rate mode: 1 for Stable, 2 for Variable
     * @param borrowRate The numeric rate at which the user has borrowed, expressed in ray
     * @param referralCode The referral code used
     */
    event Borrow(
        address indexed reserve,
        address user,
        address indexed onBehalfOf,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 borrowRate,
        uint16 indexed referralCode
    );

    /**
     * @dev Emitted on repay()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The beneficiary of the repayment, getting his debt reduced
     * @param repayer The address of the user initiating the repay(), providing the funds
     * @param amount The amount repaid
     * @param useATokens True if the repayment is done using aTokens, `false` if done with underlying asset directly
     */
    event Repay(
        address indexed reserve, address indexed user, address indexed repayer, uint256 amount, bool useATokens
    );

    /**
     * @dev Emitted on swapBorrowRateMode()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user swapping his rate mode
     * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
     */
    event SwapBorrowRateMode(
        address indexed reserve, address indexed user, DataTypes.InterestRateMode interestRateMode
    );

    /**
     * @dev Emitted on borrow(), repay() and liquidationCall() when using isolated assets
     * @param asset The address of the underlying asset of the reserve
     * @param totalDebt The total isolation mode debt for the reserve
     */
    event IsolationModeTotalDebtUpdated(address indexed asset, uint256 totalDebt);

    /**
     * @dev Emitted when the user selects a certain asset category for eMode
     * @param user The address of the user
     * @param categoryId The category id
     */
    event UserEModeSet(address indexed user, uint8 categoryId);

    /**
     * @dev Emitted on setUserUseReserveAsCollateral()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user enabling the usage as collateral
     */
    event ReserveUsedAsCollateralEnabled(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on setUserUseReserveAsCollateral()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user enabling the usage as collateral
     */
    event ReserveUsedAsCollateralDisabled(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on rebalanceStableBorrowRate()
     * @param reserve The address of the underlying asset of the reserve
     * @param user The address of the user for which the rebalance has been executed
     */
    event RebalanceStableBorrowRate(address indexed reserve, address indexed user);

    /**
     * @dev Emitted on flashLoan()
     * @param target The address of the flash loan receiver contract
     * @param initiator The address initiating the flash loan
     * @param asset The address of the asset being flash borrowed
     * @param amount The amount flash borrowed
     * @param interestRateMode The flashloan mode: 0 for regular flashloan, 1 for Stable debt, 2 for Variable debt
     * @param premium The fee flash borrowed
     * @param referralCode The referral code used
     */
    event FlashLoan(
        address indexed target,
        address initiator,
        address indexed asset,
        uint256 amount,
        DataTypes.InterestRateMode interestRateMode,
        uint256 premium,
        uint16 indexed referralCode
    );

    /**
     * @dev Emitted when a borrower is liquidated.
     * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
     * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
     * @param user The address of the borrower getting liquidated
     * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
     * @param liquidatedCollateralAmount The amount of collateral received by the liquidator
     * @param liquidator The address of the liquidator
     * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
     * to receive the underlying collateral asset directly
     */
    event LiquidationCall(
        address indexed collateralAsset,
        address indexed debtAsset,
        address indexed user,
        uint256 debtToCover,
        uint256 liquidatedCollateralAmount,
        address liquidator,
        bool receiveAToken
    );

    /**
     * @dev Emitted when the state of a reserve is updated.
     * @param reserve The address of the underlying asset of the reserve
     * @param liquidityRate The next liquidity rate
     * @param stableBorrowRate The next stable borrow rate
     * @param variableBorrowRate The next variable borrow rate
     * @param liquidityIndex The next liquidity index
     * @param variableBorrowIndex The next variable borrow index
     */
    event ReserveDataUpdated(
        address indexed reserve,
        uint256 liquidityRate,
        uint256 stableBorrowRate,
        uint256 variableBorrowRate,
        uint256 liquidityIndex,
        uint256 variableBorrowIndex
    );

    /**
     * @dev Emitted when the protocol treasury receives minted aTokens from the accrued interest.
     * @param reserve The address of the reserve
     * @param amountMinted The amount minted to the treasury
     */
    event MintedToTreasury(address indexed reserve, uint256 amountMinted);

    /**
     * @notice Mints an `amount` of aTokens to the `onBehalfOf`
     * @param asset The address of the underlying asset to mint
     * @param amount The amount to mint
     * @param onBehalfOf The address that will receive the aTokens
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     */
    function mintUnbacked(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;

    /**
     * @notice Back the current unbacked underlying with `amount` and pay `fee`.
     * @param asset The address of the underlying asset to back
     * @param amount The amount to back
     * @param fee The amount paid in fees
     * @return The backed amount
     */
    function backUnbacked(address asset, uint256 amount, uint256 fee) external returns (uint256);

    /**
     * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
     * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
     * @param asset The address of the underlying asset to supply
     * @param amount The amount to be supplied
     * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
     *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
     *   is a different wallet
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     */
    function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;

    /**
     * @notice Supply with transfer approval of asset to be supplied done via permit function
     * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
     * @param asset The address of the underlying asset to supply
     * @param amount The amount to be supplied
     * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
     *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
     *   is a different wallet
     * @param deadline The deadline timestamp that the permit is valid
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     * @param permitV The V parameter of ERC712 permit sig
     * @param permitR The R parameter of ERC712 permit sig
     * @param permitS The S parameter of ERC712 permit sig
     */
    function supplyWithPermit(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
    ) external;

    /**
     * @notice Withdraws an `amount` of underlying asset from the reserve, burning the equivalent aTokens owned
     * E.g. User has 100 aUSDC, calls withdraw() and receives 100 USDC, burning the 100 aUSDC
     * @param asset The address of the underlying asset to withdraw
     * @param amount The underlying amount to be withdrawn
     *   - Send the value type(uint256).max in order to withdraw the whole aToken balance
     * @param to The address that will receive the underlying, same as msg.sender if the user
     *   wants to receive it on his own wallet, or a different address if the beneficiary is a
     *   different wallet
     * @return The final amount withdrawn
     */
    function withdraw(address asset, uint256 amount, address to) external returns (uint256);

    /**
     * @notice Allows users to borrow a specific `amount` of the reserve underlying asset, provided that the borrower
     * already supplied enough collateral, or he was given enough allowance by a credit delegator on the
     * corresponding debt token (StableDebtToken or VariableDebtToken)
     * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
     *   and 100 stable/variable debt tokens, depending on the `interestRateMode`
     * @param asset The address of the underlying asset to borrow
     * @param amount The amount to be borrowed
     * @param interestRateMode The interest rate mode at which the user wants to borrow: 1 for Stable, 2 for Variable
     * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     * @param onBehalfOf The address of the user who will receive the debt. Should be the address of the borrower itself
     * calling the function if he wants to borrow against his own collateral, or the address of the credit delegator
     * if he has been given credit delegation allowance
     */
    function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf)
        external;

    /**
     * @notice Repays a borrowed `amount` on a specific reserve, burning the equivalent debt tokens owned
     * - E.g. User repays 100 USDC, burning 100 variable/stable debt tokens of the `onBehalfOf` address
     * @param asset The address of the borrowed underlying asset previously borrowed
     * @param amount The amount to repay
     * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
     * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
     * @param onBehalfOf The address of the user who will get his debt reduced/removed. Should be the address of the
     * user calling the function if he wants to reduce/remove his own debt, or the address of any other
     * other borrower whose debt should be removed
     * @return The final amount repaid
     */
    function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf)
        external
        returns (uint256);

    /**
     * @notice Repay with transfer approval of asset to be repaid done via permit function
     * see: https://eips.ethereum.org/EIPS/eip-2612 and https://eips.ethereum.org/EIPS/eip-713
     * @param asset The address of the borrowed underlying asset previously borrowed
     * @param amount The amount to repay
     * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
     * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
     * @param onBehalfOf Address of the user who will get his debt reduced/removed. Should be the address of the
     * user calling the function if he wants to reduce/remove his own debt, or the address of any other
     * other borrower whose debt should be removed
     * @param deadline The deadline timestamp that the permit is valid
     * @param permitV The V parameter of ERC712 permit sig
     * @param permitR The R parameter of ERC712 permit sig
     * @param permitS The S parameter of ERC712 permit sig
     * @return The final amount repaid
     */
    function repayWithPermit(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf,
        uint256 deadline,
        uint8 permitV,
        bytes32 permitR,
        bytes32 permitS
    ) external returns (uint256);

    /**
     * @notice Repays a borrowed `amount` on a specific reserve using the reserve aTokens, burning the
     * equivalent debt tokens
     * - E.g. User repays 100 USDC using 100 aUSDC, burning 100 variable/stable debt tokens
     * @dev  Passing uint256.max as amount will clean up any residual aToken dust balance, if the user aToken
     * balance is not enough to cover the whole debt
     * @param asset The address of the borrowed underlying asset previously borrowed
     * @param amount The amount to repay
     * - Send the value type(uint256).max in order to repay the whole debt for `asset` on the specific `debtMode`
     * @param interestRateMode The interest rate mode at of the debt the user wants to repay: 1 for Stable, 2 for Variable
     * @return The final amount repaid
     */
    function repayWithATokens(address asset, uint256 amount, uint256 interestRateMode) external returns (uint256);

    /**
     * @notice Allows a borrower to swap his debt between stable and variable mode, or vice versa
     * @param asset The address of the underlying asset borrowed
     * @param interestRateMode The current interest rate mode of the position being swapped: 1 for Stable, 2 for Variable
     */
    function swapBorrowRateMode(address asset, uint256 interestRateMode) external;

    /**
     * @notice Rebalances the stable interest rate of a user to the current stable rate defined on the reserve.
     * - Users can be rebalanced if the following conditions are satisfied:
     *     1. Usage ratio is above 95%
     *     2. the current supply APY is below REBALANCE_UP_THRESHOLD * maxVariableBorrowRate, which means that too
     *        much has been borrowed at a stable rate and suppliers are not earning enough
     * @param asset The address of the underlying asset borrowed
     * @param user The address of the user to be rebalanced
     */
    function rebalanceStableBorrowRate(address asset, address user) external;

    /**
     * @notice Allows suppliers to enable/disable a specific supplied asset as collateral
     * @param asset The address of the underlying asset supplied
     * @param useAsCollateral True if the user wants to use the supply as collateral, false otherwise
     */
    function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;

    /**
     * @notice Function to liquidate a non-healthy position collateral-wise, with Health Factor below 1
     * - The caller (liquidator) covers `debtToCover` amount of debt of the user getting liquidated, and receives
     *   a proportionally amount of the `collateralAsset` plus a bonus to cover market risk
     * @param collateralAsset The address of the underlying asset used as collateral, to receive as result of the liquidation
     * @param debtAsset The address of the underlying borrowed asset to be repaid with the liquidation
     * @param user The address of the borrower getting liquidated
     * @param debtToCover The debt amount of borrowed `asset` the liquidator wants to cover
     * @param receiveAToken True if the liquidators wants to receive the collateral aTokens, `false` if he wants
     * to receive the underlying collateral asset directly
     */
    function liquidationCall(
        address collateralAsset,
        address debtAsset,
        address user,
        uint256 debtToCover,
        bool receiveAToken
    ) external;

    /**
     * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
     * as long as the amount taken plus a fee is returned.
     * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
     * into consideration. For further details please visit https://docs.aave.com/developers/
     * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanReceiver interface
     * @param assets The addresses of the assets being flash-borrowed
     * @param amounts The amounts of the assets being flash-borrowed
     * @param interestRateModes Types of the debt to open if the flash loan is not returned:
     *   0 -> Don't open any debt, just revert if funds can't be transferred from the receiver
     *   1 -> Open debt at stable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
     *   2 -> Open debt at variable rate for the value of the amount flash-borrowed to the `onBehalfOf` address
     * @param onBehalfOf The address  that will receive the debt in the case of using on `modes` 1 or 2
     * @param params Variadic packed params to pass to the receiver as extra information
     * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     */
    function flashLoan(
        address receiverAddress,
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata interestRateModes,
        address onBehalfOf,
        bytes calldata params,
        uint16 referralCode
    ) external;

    /**
     * @notice Allows smartcontracts to access the liquidity of the pool within one transaction,
     * as long as the amount taken plus a fee is returned.
     * @dev IMPORTANT There are security concerns for developers of flashloan receiver contracts that must be kept
     * into consideration. For further details please visit https://docs.aave.com/developers/
     * @param receiverAddress The address of the contract receiving the funds, implementing IFlashLoanSimpleReceiver interface
     * @param asset The address of the asset being flash-borrowed
     * @param amount The amount of the asset being flash-borrowed
     * @param params Variadic packed params to pass to the receiver as extra information
     * @param referralCode The code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     */
    function flashLoanSimple(
        address receiverAddress,
        address asset,
        uint256 amount,
        bytes calldata params,
        uint16 referralCode
    ) external;

    /**
     * @notice Returns the user account data across all the reserves
     * @param user The address of the user
     * @return totalCollateralBase The total collateral of the user in the base currency used by the price feed
     * @return totalDebtBase The total debt of the user in the base currency used by the price feed
     * @return availableBorrowsBase The borrowing power left of the user in the base currency used by the price feed
     * @return currentLiquidationThreshold The liquidation threshold of the user
     * @return ltv The loan to value of The user
     * @return healthFactor The current health factor of the user
     */
    function getUserAccountData(address user)
        external
        view
        returns (
            uint256 totalCollateralBase,
            uint256 totalDebtBase,
            uint256 availableBorrowsBase,
            uint256 currentLiquidationThreshold,
            uint256 ltv,
            uint256 healthFactor
        );

    /**
     * @notice Initializes a reserve, activating it, assigning an aToken and debt tokens and an
     * interest rate strategy
     * @dev Only callable by the PoolConfigurator contract
     * @param asset The address of the underlying asset of the reserve
     * @param aTokenAddress The address of the aToken that will be assigned to the reserve
     * @param stableDebtAddress The address of the StableDebtToken that will be assigned to the reserve
     * @param variableDebtAddress The address of the VariableDebtToken that will be assigned to the reserve
     * @param interestRateStrategyAddress The address of the interest rate strategy contract
     */
    function initReserve(
        address asset,
        address aTokenAddress,
        address stableDebtAddress,
        address variableDebtAddress,
        address interestRateStrategyAddress
    ) external;

    /**
     * @notice Drop a reserve
     * @dev Only callable by the PoolConfigurator contract
     * @param asset The address of the underlying asset of the reserve
     */
    function dropReserve(address asset) external;

    /**
     * @notice Updates the address of the interest rate strategy contract
     * @dev Only callable by the PoolConfigurator contract
     * @param asset The address of the underlying asset of the reserve
     * @param rateStrategyAddress The address of the interest rate strategy contract
     */
    function setReserveInterestRateStrategyAddress(address asset, address rateStrategyAddress) external;

    /**
     * @notice Sets the configuration bitmap of the reserve as a whole
     * @dev Only callable by the PoolConfigurator contract
     * @param asset The address of the underlying asset of the reserve
     * @param configuration The new configuration bitmap
     */
    function setConfiguration(address asset, DataTypes.ReserveConfigurationMap calldata configuration) external;

    /**
     * @notice Returns the configuration of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The configuration of the reserve
     */
    function getConfiguration(address asset) external view returns (DataTypes.ReserveConfigurationMap memory);

    /**
     * @notice Returns the configuration of the user across all the reserves
     * @param user The user address
     * @return The configuration of the user
     */
    function getUserConfiguration(address user) external view returns (DataTypes.UserConfigurationMap memory);

    /**
     * @notice Returns the normalized income of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The reserve's normalized income
     */
    function getReserveNormalizedIncome(address asset) external view returns (uint256);

    /**
     * @notice Returns the normalized variable debt per unit of asset
     * @dev WARNING: This function is intended to be used primarily by the protocol itself to get a
     * "dynamic" variable index based on time, current stored index and virtual rate at the current
     * moment (approx. a borrower would get if opening a position). This means that is always used in
     * combination with variable debt supply/balances.
     * If using this function externally, consider that is possible to have an increasing normalized
     * variable debt that is not equivalent to how the variable debt index would be updated in storage
     * (e.g. only updates with non-zero variable debt supply)
     * @param asset The address of the underlying asset of the reserve
     * @return The reserve normalized variable debt
     */
    function getReserveNormalizedVariableDebt(address asset) external view returns (uint256);

    /**
     * @notice Returns the state and configuration of the reserve
     * @param asset The address of the underlying asset of the reserve
     * @return The state and configuration data of the reserve
     */
    function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);

    /**
     * @notice Validates and finalizes an aToken transfer
     * @dev Only callable by the overlying aToken of the `asset`
     * @param asset The address of the underlying asset of the aToken
     * @param from The user from which the aTokens are transferred
     * @param to The user receiving the aTokens
     * @param amount The amount being transferred/withdrawn
     * @param balanceFromBefore The aToken balance of the `from` user before the transfer
     * @param balanceToBefore The aToken balance of the `to` user before the transfer
     */
    function finalizeTransfer(
        address asset,
        address from,
        address to,
        uint256 amount,
        uint256 balanceFromBefore,
        uint256 balanceToBefore
    ) external;

    /**
     * @notice Returns the list of the underlying assets of all the initialized reserves
     * @dev It does not include dropped reserves
     * @return The addresses of the underlying assets of the initialized reserves
     */
    function getReservesList() external view returns (address[] memory);

    /**
     * @notice Returns the address of the underlying asset of a reserve by the reserve id as stored in the DataTypes.ReserveData struct
     * @param id The id of the reserve as stored in the DataTypes.ReserveData struct
     * @return The address of the reserve associated with id
     */
    function getReserveAddressById(uint16 id) external view returns (address);

    /**
     * @notice Returns the PoolAddressesProvider connected to this contract
     * @return The address of the PoolAddressesProvider
     */
    function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);

    /**
     * @notice Updates the protocol fee on the bridging
     * @param bridgeProtocolFee The part of the premium sent to the protocol treasury
     */
    function updateBridgeProtocolFee(uint256 bridgeProtocolFee) external;

    /**
     * @notice Updates flash loan premiums. Flash loan premium consists of two parts:
     * - A part is sent to aToken holders as extra, one time accumulated interest
     * - A part is collected by the protocol treasury
     * @dev The total premium is calculated on the total borrowed amount
     * @dev The premium to protocol is calculated on the total premium, being a percentage of `flashLoanPremiumTotal`
     * @dev Only callable by the PoolConfigurator contract
     * @param flashLoanPremiumTotal The total premium, expressed in bps
     * @param flashLoanPremiumToProtocol The part of the premium sent to the protocol treasury, expressed in bps
     */
    function updateFlashloanPremiums(uint128 flashLoanPremiumTotal, uint128 flashLoanPremiumToProtocol) external;

    /**
     * @notice Configures a new category for the eMode.
     * @dev In eMode, the protocol allows very high borrowing power to borrow assets of the same category.
     * The category 0 is reserved as it's the default for volatile assets
     * @param id The id of the category
     * @param config The configuration of the category
     */
    function configureEModeCategory(uint8 id, DataTypes.EModeCategory memory config) external;

    /**
     * @notice Returns the data of an eMode category
     * @param id The id of the category
     * @return The configuration data of the category
     */
    function getEModeCategoryData(uint8 id) external view returns (DataTypes.EModeCategory memory);

    /**
     * @notice Allows a user to use the protocol in eMode
     * @param categoryId The id of the category
     */
    function setUserEMode(uint8 categoryId) external;

    /**
     * @notice Returns the eMode the user is using
     * @param user The address of the user
     * @return The eMode id
     */
    function getUserEMode(address user) external view returns (uint256);

    /**
     * @notice Resets the isolation mode total debt of the given asset to zero
     * @dev It requires the given asset has zero debt ceiling
     * @param asset The address of the underlying asset to reset the isolationModeTotalDebt
     */
    function resetIsolationModeTotalDebt(address asset) external;

    /**
     * @notice Returns the percentage of available liquidity that can be borrowed at once at stable rate
     * @return The percentage of available liquidity to borrow, expressed in bps
     */
    function MAX_STABLE_RATE_BORROW_SIZE_PERCENT() external view returns (uint256);

    /**
     * @notice Returns the total fee on flash loans
     * @return The total fee on flashloans
     */
    function FLASHLOAN_PREMIUM_TOTAL() external view returns (uint128);

    /**
     * @notice Returns the part of the bridge fees sent to protocol
     * @return The bridge fee sent to the protocol treasury
     */
    function BRIDGE_PROTOCOL_FEE() external view returns (uint256);

    /**
     * @notice Returns the part of the flashloan fees sent to protocol
     * @return The flashloan fee sent to the protocol treasury
     */
    function FLASHLOAN_PREMIUM_TO_PROTOCOL() external view returns (uint128);

    /**
     * @notice Returns the maximum number of reserves supported to be listed in this Pool
     * @return The maximum number of reserves supported
     */
    function MAX_NUMBER_RESERVES() external view returns (uint16);

    /**
     * @notice Mints the assets accrued through the reserve factor to the treasury in the form of aTokens
     * @param assets The list of reserves for which the minting needs to be executed
     */
    function mintToTreasury(address[] calldata assets) external;

    /**
     * @notice Rescue and transfer tokens locked in this contract
     * @param token The address of the token
     * @param to The address of the recipient
     * @param amount The amount of token to transfer
     */
    function rescueTokens(address token, address to, uint256 amount) external;

    /**
     * @notice Supplies an `amount` of underlying asset into the reserve, receiving in return overlying aTokens.
     * - E.g. User supplies 100 USDC and gets in return 100 aUSDC
     * @dev Deprecated: Use the `supply` function instead
     * @param asset The address of the underlying asset to supply
     * @param amount The amount to be supplied
     * @param onBehalfOf The address that will receive the aTokens, same as msg.sender if the user
     *   wants to receive them on his own wallet, or a different address if the beneficiary of aTokens
     *   is a different wallet
     * @param referralCode Code used to register the integrator originating the operation, for potential rewards.
     *   0 if the action is executed directly by the user, without any middle-man
     */
    function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
}

// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;

import {IPoolAddressesProvider} from "./IPoolAddressesProvider.sol";

/**
 * @title IACLManager
 * @author Aave
 * @notice Defines the basic interface for the ACL Manager
 */
interface IACLManager {
    /**
     * @notice Returns the contract address of the PoolAddressesProvider
     * @return The address of the PoolAddressesProvider
     */
    function ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);

    /**
     * @notice Returns the identifier of the PoolAdmin role
     * @return The id of the PoolAdmin role
     */
    function POOL_ADMIN_ROLE() external view returns (bytes32);

    /**
     * @notice Returns the identifier of the EmergencyAdmin role
     * @return The id of the EmergencyAdmin role
     */
    function EMERGENCY_ADMIN_ROLE() external view returns (bytes32);

    /**
     * @notice Returns the identifier of the RiskAdmin role
     * @return The id of the RiskAdmin role
     */
    function RISK_ADMIN_ROLE() external view returns (bytes32);

    /**
     * @notice Returns the identifier of the FlashBorrower role
     * @return The id of the FlashBorrower role
     */
    function FLASH_BORROWER_ROLE() external view returns (bytes32);

    /**
     * @notice Returns the identifier of the Bridge role
     * @return The id of the Bridge role
     */
    function BRIDGE_ROLE() external view returns (bytes32);

    /**
     * @notice Returns the identifier of the AssetListingAdmin role
     * @return The id of the AssetListingAdmin role
     */
    function ASSET_LISTING_ADMIN_ROLE() external view returns (bytes32);

    /**
     * @notice Set the role as admin of a specific role.
     * @dev By default the admin role for all roles is `DEFAULT_ADMIN_ROLE`.
     * @param role The role to be managed by the admin role
     * @param adminRole The admin role
     */
    function setRoleAdmin(bytes32 role, bytes32 adminRole) external;

    /**
     * @notice Adds a new admin as PoolAdmin
     * @param admin The address of the new admin
     */
    function addPoolAdmin(address admin) external;

    /**
     * @notice Removes an admin as PoolAdmin
     * @param admin The address of the admin to remove
     */
    function removePoolAdmin(address admin) external;

    /**
     * @notice Returns true if the address is PoolAdmin, false otherwise
     * @param admin The address to check
     * @return True if the given address is PoolAdmin, false otherwise
     */
    function isPoolAdmin(address admin) external view returns (bool);

    /**
     * @notice Adds a new admin as EmergencyAdmin
     * @param admin The address of the new admin
     */
    function addEmergencyAdmin(address admin) external;

    /**
     * @notice Removes an admin as EmergencyAdmin
     * @param admin The address of the admin to remove
     */
    function removeEmergencyAdmin(address admin) external;

    /**
     * @notice Returns true if the address is EmergencyAdmin, false otherwise
     * @param admin The address to check
     * @return True if the given address is EmergencyAdmin, false otherwise
     */
    function isEmergencyAdmin(address admin) external view returns (bool);

    /**
     * @notice Adds a new admin as RiskAdmin
     * @param admin The address of the new admin
     */
    function addRiskAdmin(address admin) external;

    /**
     * @notice Removes an admin as RiskAdmin
     * @param admin The address of the admin to remove
     */
    function removeRiskAdmin(address admin) external;

    /**
     * @notice Returns true if the address is RiskAdmin, false otherwise
     * @param admin The address to check
     * @return True if the given address is RiskAdmin, false otherwise
     */
    function isRiskAdmin(address admin) external view returns (bool);

    /**
     * @notice Adds a new address as FlashBorrower
     * @param borrower The address of the new FlashBorrower
     */
    function addFlashBorrower(address borrower) external;

    /**
     * @notice Removes an address as FlashBorrower
     * @param borrower The address of the FlashBorrower to remove
     */
    function removeFlashBorrower(address borrower) external;

    /**
     * @notice Returns true if the address is FlashBorrower, false otherwise
     * @param borrower The address to check
     * @return True if the given address is FlashBorrower, false otherwise
     */
    function isFlashBorrower(address borrower) external view returns (bool);

    /**
     * @notice Adds a new address as Bridge
     * @param bridge The address of the new Bridge
     */
    function addBridge(address bridge) external;

    /**
     * @notice Removes an address as Bridge
     * @param bridge The address of the bridge to remove
     */
    function removeBridge(address bridge) external;

    /**
     * @notice Returns true if the address is Bridge, false otherwise
     * @param bridge The address to check
     * @return True if the given address is Bridge, false otherwise
     */
    function isBridge(address bridge) external view returns (bool);

    /**
     * @notice Adds a new admin as AssetListingAdmin
     * @param admin The address of the new admin
     */
    function addAssetListingAdmin(address admin) external;

    /**
     * @notice Removes an admin as AssetListingAdmin
     * @param admin The address of the admin to remove
     */
    function removeAssetListingAdmin(address admin) external;

    /**
     * @notice Returns true if the address is AssetListingAdmin, false otherwise
     * @param admin The address to check
     * @return True if the given address is AssetListingAdmin, false otherwise
     */
    function isAssetListingAdmin(address admin) external view returns (bool);
}

{
  "viaIR": false,
  "codegen": "yul",
  "remappings": [
    "aave-helpers/=lib/aave-helpers/src/",
    "aave-address-book/=lib/aave-address-book/src/",
    "aave-v3-origin/=lib/aave-address-book/lib/aave-v3-origin/src/",
    "solidity-utils/=lib/solidity-utils/src/",
    "openzeppelin-contracts-8/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/",
    "@aave/core-v3/contracts/=src/aave-v3-core/",
    "@aave/periphery-v3/contracts/=src/aave-v3-periphery/",
    "@pythnetwork/pyth-sdk-solidity/=node_modules/@pythnetwork/pyth-sdk-solidity/",
    "@openzeppelin/contracts-upgradeable/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
    "aave-v3-origin-tests/=lib/aave-helpers/lib/aave-address-book/lib/aave-v3-origin/tests/",
    "ds-test/=lib/aave-address-book/lib/aave-v3-origin/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "forge-zksync-std/=lib/forge-zksync-std/src/",
    "halmos-cheatcodes/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts-upgradeable/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/"
  ],
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "abi"
      ]
    }
  },
  "optimizer": {
    "enabled": true,
    "mode": "3",
    "size_fallback": false,
    "disable_system_request_memoization": true
  },
  "metadata": {},
  "libraries": {
    "src/aave-v3-core/protocol/libraries/logic/BorrowLogic.sol": {
      "BorrowLogic": "0x705AceDB1e33D245D16c16423124ce89C0ACC1Fd"
    },
    "src/aave-v3-core/protocol/libraries/logic/ConfiguratorLogic.sol": {
      "ConfiguratorLogic": "0x4e39bE2C04D9a5606BAA60A549C22A9B9887f5cf"
    },
    "src/aave-v3-core/protocol/libraries/logic/EModeLogic.sol": {
      "EModeLogic": "0x4A5703c7cccA842f6069Aa46526DC89e9F5D11f3"
    }
  },
  "enableEraVMExtensions": false,
  "forceEVMLA": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalDebt","type":"uint256"}],"name":"IsolationModeTotalDebtUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collateralAsset","type":"address"},{"indexed":true,"internalType":"address","name":"debtAsset","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"debtToCover","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidatedCollateralAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"liquidator","type":"address"},{"indexed":false,"internalType":"bool","name":"receiveAToken","type":"bool"}],"name":"LiquidationCall","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"reserve","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidityRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"stableBorrowRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"variableBorrowRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidityIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"variableBorrowIndex","type":"uint256"}],"name":"ReserveDataUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"reserve","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"ReserveUsedAsCollateralDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"reserve","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"}],"name":"ReserveUsedAsCollateralEnabled","type":"event"},{"inputs":[],"name":"CLOSE_FACTOR_HF_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_LIQUIDATION_CLOSE_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

9c4d535b0000000000000000000000000000000000000000000000000000000000000000010006077b9a2de81c2db94e3f18b491caf24d4039dc959edc96a375d6e910ee00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000

0x002f0000000000020000008003000039000000400030043f00000001002001900000009e0000c13d0000006002100270000005a002200197000000040020008c000005bb0000413d000000000301043b000000e003300270000005a20030009c000000ae0000613d000005a30030009c000000aa0000613d000005a40030009c000005bb0000c13d00000000030004100000000004000412000000000034004b000005bb0000613d000001a40020008c000005bb0000413d000001a002000039000000400020043f0000008402100370000000000202043b000000800020043f000000a402100370000000000202043b000000a00020043f000000c402100370000000000202043b000005a70020009c000005bb0000213d000000c00020043f000000e402100370000000000202043b000005a70020009c000005bb0000213d000000e00020043f0000010402100370000000000202043b000005a70020009c000005bb0000213d000001000020043f0000012402100370000000000202043b000000010020008c000005bb0000213d000001200020043f0000014402100370000000000202043b000005a70020009c000005bb0000213d000001400020043f0000016402100370000000000202043b000000ff0020008c000005bb0000213d000001600020043f0000018402100370000000000202043b000005a70020009c000005bb0000213d000001800020043f0000000402100370000000000202043b001900000002001d0000002402100370000000000202043b001f00000002001d0000004402100370000000000202043b001400000002001d0000006401100370000000000101043b001300000001001d0000000001000415001200000001001d000000400100043d001500000001001d000005a80010009c000000980000813d00000015020000290000018001200039000000400010043f0000014001200039000b00000001001d00000000000104350000012001200039000a00000001001d00000000000104350000010001200039000900000001001d0000000000010435000000e001200039000c00000001001d0000000000010435000000c001200039001100000001001d0000000000010435000000a001200039000800000001001d00000000000104350000008001200039000d00000001001d00000000000104350000006001200039001000000001001d00000000000104350000004001200039000e00000001001d00000000000104350000000001020436000f00000001001d0000000000010435000000400100043d000005a90010009c000000980000213d0000028002100039000000400020043f000001a00210003900000000000204350000018002100039000000000002043500000160021000390000000000020435000001400210003900000000000204350000012002100039000000000002043500000100021000390000000000020435000000e0021000390000000000020435000000c0021000390000000000020435000000a0021000390000000000020435000000800210003900000000000204350000006002100039000000000002043500000040021000390000000000020435000000200210003900000000000204350000000000010435000000400200043d000005aa0020009c000000b20000a13d000005f501000041000000000010043f0000004101000039000000040010043f000005af010000410000167f000104300000000001000416000000000001004b000005bb0000c13d0000014000000443000000000100041000000160001004430000002001000039000001000010044300000001010000390000012000100443000005a1010000410000167e0001042e000005a601000041000000800010043f000005a5010000410000167e0001042e0000271001000039000000800010043f000005a5010000410000167e0001042e0000002003200039000000400030043f0000000000020435000001c003100039000000000023043500000260021000390000000000020435000002400210003900000000000204350000022002100039000000000002043500000200021000390000000000020435000001e002100039000000000002043500000015020000290000016002200039000700000002001d0000000000120435000000c00100043d000005a701100197000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000600000001001d000000e00100043d000005a701100197000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000500000001001d000001000100043d000005a701100197000000000010043f0000001401000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000400000001001d0000000501000029167d138f0000040f0000000002010019000000070100002900000000002104350000000501000029167d14f00000040f000000400100043d002300000001001d000005ac0010009c000000980000213d000000800100043d0000002302000029000000a002200039000001600300043d000001400400043d000001000500043d000000400020043f000005aa0020009c000000980000213d000000ff0330018f000005a704400197000005a7055001970000002307000029000000c006700039000000400060043f0000000406000029000000000606041a00000000006204350000008006700039001800000006001d00000000003604350000006003700039001600000003001d00000000004304350000004003700039001700000003001d00000000005304350000002003700039002100000003001d000000000013043500000000002704350000000001000415000300000001001d00000000010704330000000001010433000000000001004b0000025b0000c13d002400010000009200000000010004150000000301100069000000000100000200000011010000290000002402000029000000000021043500000007010000290000000001010433002200000001001d00000200011000390000000002000415002000000002001d0000000002010433000001000100043d000000400400043d002500000004001d000005c0030000410000000000340435000005a7031001970000000401400039002100000003001d0000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000250b0000290000002505700029000001580000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000001540000c13d000000000006004b000001650000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000057e0000613d0000001f01400039000000600110018f0000000002b10019000000000012004b00000000010000390000000101004039002300000002001d000005b10020009c000000980000213d0000000100100190000000980000c13d0000002301000029000000400010043f000000200030008c000005bb0000413d00000000010b0433002500000001001d000000220100002900000220011000390000000002010433000005c00100004100000023040000290000000000140435000000040140003900000021030000290000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f000000200740019000000023057000290000019c0000613d000000000801034f0000002309000029000000008a08043c0000000009a90436000000000059004b000001980000c13d000000000006004b000001a90000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000005bd0000613d0000001f01400039000000600110018f0000002301100029000005b10010009c000000980000213d000000400010043f000000200030008c000005bb0000413d00000023010000290000000001010433000000250010002a000012a30000413d00000025021000290000002403000029000005c20030009c000005c403000041000005c303004041000000000023004b000005bb0000413d000000a00300043d0000000004000415000000200440006900000000040000020000002404000029000005c20040009c0000138804000039000027100400403900000000044200a90000138804400039000027100440011a000000000043004b0000000003048019000000100400002900000000003404350000000e0300002900000000002304350000000f030000290000000000130435000000400300043d000005c50030009c000000980000213d00000007010000290000000004010433000000110100002900000000050104330000008001300039000001800600043d000000400010043f000005a706600197000000600130003900000000006104350000004006300039002500000006001d00000000005604350000000004430436002400000004001d00000000002404350000000002000415002300000002001d000000400500043d000005ac0050009c000000980000213d000000a002500039000000400020043f0000008002500039002200000002001d0000000000020435000000600250003900000000000204350000004006500039000000000006043500000000040504360000000000040435000000400700043d000005aa0070009c000000980000213d0000002008700039000000400080043f0000000608000029000000000808041a00000000008704350000003c07800270000000010770018f00000000007404350000003807800270000000010770018f00000000007504350000000003030433000001c003300039000000000303043300000000030304330000003c05300270000000010550018f00000000005204350000003803300270000000010830018f0000000000860435000000400500043d000005b20050009c000000980000213d0000004003500039000000400030043f00000002030000390000000003350436000005c6060000410000000000630435000000000007004b0000069f0000613d000000000008004b0000069f0000613d0000000003040433000000000003004b0000000004000019000002210000c13d0000000002020433000000000002004b00000000040000390000000104006039000000400300043d000005b20030009c000000980000213d0000004002300039000000400020043f00000002020000390000000002230436000005c7050000410000000000520435000000400500043d002100000005001d0000000100400190000006b90000613d00000001030000390000000001010433000005a702100198000002360000613d00000025010000290000000001010433000005a60010009c000006db0000813d0000002102000029000005b20020009c000000980000213d0000004001200039000000400010043f00000002010000390000000004120436000005ca010000410000000000140435000000400100043d000000000003004b000007190000c13d000005bf0300004100000000003104350000000403100039000000200500003900000000005304350000000002020433000000240310003900000000002304350000004403100039000000000002004b000002550000613d000000000500001900000000063500190000000007450019000000000707043300000000007604350000002005500039000000000025004b0000024e0000413d0000001f04200039000005f6044001970000000002230019000000000002043500000044024000390000064f0000013d000000400100043d002500000001001d000005ad0010009c000000980000213d00000025020000290000026001200039000000400010043f000002400120003900000000000104350000022001200039000000000001043500000200012000390000000000010435000001e0012000390000000000010435000001600120003900000000000104350000014001200039000000000001043500000120012000390000000000010435000000e0012000390000000000010435000000a0012000390000000000010435000000800120003900000000000104350000004001200039000000000001043500000020012000390000000000010435000001c001200039001d00000001001d0000000000010435000001a001200039001e00000001001d00000000000104350000018001200039001c00000001001d00000000000104350000010001200039002000000001001d0000000000010435000000c001200039002400000001001d00000000000104350000006001200039002200000001001d00000000000104350000000000020435002f00000002001d00000018010000290000000001010433000000ff021001900000000001000019000002b90000613d000000000020043f0000001301000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d00000016020000290000000002020433000000000101043b0000000003000415001a00000003001d000000000101041a001b00000001001d0000003001100270000005a7011001980000000003000019000005c90000c13d00000000010004150000001a0110006900000000010000020000001c0100002900000000003104350000001b0300002900000010013002700000ffff0110018f0000001d0200002900000000001204350000ffff0130018f0000001e02000029000000000012043500000024010000290000000001010433002e00220000002d00000021020000290000000002020433000000000021004b000002d80000413d00000025010000290000016002100039000001400310003900000020010000290000000001010433000000000001004b0000059c0000c13d000000000003043500000000040004150000002d0440008a00000005044002100000000003000019000005a40000013d00000025050000290000002402000029000000000102043300000001011000390000000000120435002500000005001d000000c001500039002400000001001d000000000101043300000021020000290000000002020433000000000021004b000006330000813d000000400300043d000005b20030009c000000980000213d000000230200002900000000040204330000004002300039000000400020043f00000002020000390000000002230436000005b3050000410000000000520435000000800010008c0000061e0000813d00000001011002100000000002040433000000000112022f0000000300100190000002cb0000613d00000024010000290000000001010433000000000010043f0000001f01000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d00000025050000290000020002500039000000000101043b000000000101041a000005a7011001980000000000120435000002cc0000613d002000000002001d000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b002200000001001d002c00000001001d000000400100043d000005aa0010009c000000980000213d0000002002100039000000400020043f0000002202000029000000000402041a0000000000410435000000a801400270000000ff0210018f0000002507000029000001e00170003900000000002104350000003001400270000000ff031001900000002e01000029000000000031043500000080017000390000ffff0540018f0000000000510435000000a00870003900000010014002700000ffff0110018f00000000001804350000000104000039000003310000613d0000000a05000039000000010030019000000000065500a9000000010500603900000000044500a9000000010330027200000000050600190000032a0000c13d0000002003700039000000000043043500000180037000390000000003030433000000000003004b000003410000613d00000000050004150000002a0550008a000000050550021000000018040000290000000004040433002a00000000003d000000ff0440018f000000000024004b000003450000c13d0000038e0000013d00000000050004150000002b0550008a0000000505500210002b00000000003d001d00000005001d001e00000008001d0000001601000029000000000201043300000020010000290000000001010433000000400400043d002000000004001d000005ae030000410000000000340435000005a70110019700000004034000390000000000130435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f000000200a0000290000006003100270000005a003300197000000200030008c00000020040000390000000004034019000000200640019000000000056a00190000036d0000613d000000000701034f00000000080a0019000000007907043c0000000008980436000000000058004b000003690000c13d0000001f074001900000037a0000613d000000000661034f0000000307700210000000000805043300000000087801cf000000000878022f000000000606043b0000010007700089000000000676022f00000000067601cf000000000686019f00000000006504350000000100200190000006570000613d0000001f01400039000000600210018f0000000001a20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d0000001e01000029000000000101043300000000030a043300000025070000290000001d050000290000000502500270000000000203001f0000000000370435000000000001004b000003cc0000613d000000400300043d000005b20030009c000000980000213d00000024010000290000000004010433000000230100002900000000010104330000004002300039000000400020043f00000002020000390000000002230436000005b3050000410000000000520435000000800040008c000006630000813d00000001024002100000000001010433000000000121022f0000002f020000290000000200100190002500000002001d0000048b0000613d0000000012020434002000000002001d0000000001010433001d00000001001d00000017010000290000000001010433001e00000001001d000000220100002900000003011000390000000002000415001c00000002001d000000000101041a002400000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000013720000613d00000024020000290000008002200270000005b60320019700000022020000290000000102200039000000000202041a000000000101043b000000000013004b000003ce0000c13d000005ba01200197000003f00000013d0025002f0000002d0000048b0000013d001b00000003001d002400000002001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000013720000613d000000000101043b0000001b0110006c0000002404000029000012a30000413d000000800340027000000000023100a9000005b70040009c000003e60000413d00000000033200d9000000000013004b000012a30000c13d000005b80120012a000005b90110009a000005ba02400198000003ed0000613d000005bb03200129000000000013004b000005bb0000413d00000000012100a9000005bc0110009a000005bd0110012a002400000001001d0000001e01000029000005a70110019700000022020000290000000402200039000000000202041a000000400400043d002200000004001d000005be03000041000000000034043500000004034000390000000000130435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f000000220a0000290000006003100270000005a003300197000000200030008c00000020040000390000000004034019000000200640019000000000056a0019000004170000613d000000000701034f00000000080a0019000000007907043c0000000008980436000000000058004b000004130000c13d0000001f07400190000004240000613d000000000661034f0000000307700210000000000805043300000000087801cf000000000878022f000000000606043b0000010007700089000000000676022f00000000067601cf000000000686019f00000000006504350000000100200190000006930000613d0000001f01400039000000600210018f0000000001a20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000010a0433000000240000006b0000043a0000613d0000002402000029000005bb02200129000000000012004b000005bb0000413d00000024011000b9000005bc0310009a000005bd0230012a00000020012000b9000005bd0030009c00000025070000290000001d08000029000004450000413d00000000022100d9000000200020006c000012a30000c13d000000000008004b00000d230000613d00000000020004150000001c02200069000000000200000200000000028100d90000004003700039000000000023043500000100037000390000000004030433000000000024001a000012a30000413d00000000042400190000000000430435000001e003700039000000000303043300000018040000290000000004040433000000ff0440018f000000000043004b00000000030000390000000103006039000000000004004b0000000004000039000000010400c039000000000334016f0000024004700039000000000034043500000080047000390000000005040433000000000005004b000000010330018f000004770000613d000001a005700039000000000003004b0000000005046019000000000505043300000000042500a9000000000018004b000004700000213d00000000062400d9000000000056004b000012a30000c13d00000140057000390000000006050433000000000046001a000012a30000413d000000000446001900000000004504350000047a0000013d000002200470003900000001050000390000000000540435000000000003004b000000a003000039000001c00300c0390000000003730019000000000403043300000000032400a9000000000018004b000004850000213d00000000012300d9000000000041004b000012a30000c13d00000160017000390000000002010433000000000032001a000012a30000413d00000000023200190000000000210435000000400300043d000005b20030009c000000980000213d000000230100002900000000010104330000002505000029000000c002500039002400000002001d00000000040204330000004002300039000000400020043f00000002020000390000000002230436000005b3060000410000000000620435000000800040008c000006360000813d00000001024002100000000001010433000000000121022f0000000100100190000002cc0000613d0000000012050434001d00000002001d0000000001010433001c00000001001d000000170100002900000000010104330000002c02000029002200000002001d00000006022000390000000003000415001b00000003001d000000000202041a000000400400043d002000000004001d000005be030000410000000000340435000005a7031001970000000401400039001e00000003001d0000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f000000200a0000290000006003100270000005a003300197000000200030008c00000020040000390000000004034019000000200640019000000000056a0019000004d00000613d000000000701034f00000000080a0019000000007907043c0000000008980436000000000058004b000004cc0000c13d0000001f07400190000004dd0000613d000000000661034f0000000307700210000000000805043300000000087801cf000000000878022f000000000606043b0000010007700089000000000676022f00000000067601cf000000000686019f000000000065043500000001002001900000067b0000613d0000001f01400039000000600110018f0000000002a10019000000000012004b00000000010000390000000101004039000005b10020009c000000980000213d0000000100100190000000980000c13d0000000004020019000000400020043f000000200030008c000005bb0000413d00000000010a0433002000000001001d000000000001004b0000050b0000613d00000022010000290000000301100039000000000101041a001a00000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000013720000613d0000001a020000290000008002200270000005b60220019700000022030000290000000203300039000000000403041a000000000301043b000000000032004b0000050d0000c13d000005ba01400197000005190000013d001a00000000001d000005220000013d0000008001400270001a00000004001d167d161f0000040f0000001a02000029000005ba02200198000005160000613d000005bb03200129000000000013004b000005bb0000413d00000000011200a9000005bc0110009a000005bd0110012a000000000001004b0000051e0000613d000005bb02100129000000200020006c000005bb0000413d00000020011000b9000000400400043d000005bc0110009a001a05bd001001320000002201000029002000000004001d0000000501100039000000000201041a000005c001000041000000000014043500000004014000390000001e030000290000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f000000200a0000290000006003100270000005a003300197000000200030008c00000020040000390000000004034019000000200640019000000000056a0019000005460000613d000000000701034f00000000080a0019000000007907043c0000000008980436000000000058004b000005420000c13d0000001f07400190000005530000613d000000000661034f0000000307700210000000000805043300000000087801cf000000000878022f000000000606043b0000010007700089000000000676022f00000000067601cf000000000686019f00000000006504350000000100200190000006870000613d0000001f01400039000000600210018f0000000001a20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d000000200100002900000000010104330000001a02000029000000000012001a00000025050000290000001d03000029000012a30000413d000000000212001900000000013200a9000000000003004b000005700000613d00000000033100d9000000000023004b000012a30000c13d0000001c03000029000000000003004b00000d230000613d00000000020004150000001b02200069000000000200000200000000023100d900000120015000390000000003010433000000000023001a000012a30000413d00000000022300190000000000210435000002cc0000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000005850000c13d000000000005004b000005960000613d000000000161034f0000000305500210000000000604043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f00000000001404350000006001300210000005a00020009c000005a0020080410000004002200210000000000112019f0000167f00010430000000000403043300000000041400d90000000000430435000000000302043300000000031300d90000000004000415000000290440008a00000005044002100000000504400270000000000403001f0000000000320435000000250200002900000120022000390000000002020433000000000002004b000005ae0000c13d000000010100008a0000060c0000013d000000000003004b000005b30000613d000005f704300129000000000014004b000005bb0000413d00000000031300a90000000101200270000005f8041001670000138803300039000027100330011a000005c10440012a000000000034004b000006090000813d00000000010000190000167f000104300000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000005c40000c13d000005890000013d000000400400043d000200000004001d000005ae03000041000000000034043500000004034000390000000000130435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000020b0000290000000205700029000005eb0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000005e70000c13d000000000006004b000005f80000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000006120000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000030b0433000002aa0000013d000005c1033000d1000000000113001900000000012100d9002400000001001d0000002501000029000000e00110003900000024020000290000000000210435000001260000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000006190000c13d000005890000013d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b0000062b0000413d0000064a0000013d0000002501000029002001000010003d000002be0000013d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b000006430000413d0000001f02300039000005f602200197000000000334001900000000000304350000004402200039000005a00020009c000005a0020080410000006002200210000005a00010009c000005a0010080410000004001100210000000000112019f0000167f000104300000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000065e0000c13d000005890000013d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b000006770000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b000006700000413d0000001f02300039000005f60220019700000000034300190000064d0000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000006820000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000068e0000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000069a0000c13d000005890000013d000000400100043d000005bf0200004100000000002104350000000402100039000000200400003900000000004204350000000002050433000000240410003900000000002404350000004404100039000000000002004b000006b30000613d000000000500001900000000064500190000000007350019000000000707043300000000007604350000002005500039000000000025004b000006ac0000413d0000001f03200039000005f6033001970000000002240019000000000002043500000044023000390000064f0000013d000005bf01000041000000210500002900000000001504350000000401500039000000200400003900000000004104350000000001030433000000240350003900000000001304350000004403500039000000000001004b000006cd0000613d000000000400001900000000053400190000000006240019000000000606043300000000006504350000002004400039000000000014004b000006c60000413d0000001f02100039000005f602200197000000000113001900000000000104350000004401200039000005a00010009c000005a00100804100000060011002100000002102000029000005a00020009c000005a0020080410000004002200210000000000121019f0000167f00010430000005c80100004100000021030000290000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f00000020074001900000002105700029000006f80000613d000000000801034f0000002109000029000000008a08043c0000000009a90436000000000059004b000006f40000c13d000000000006004b000007050000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000007420000613d0000001f01400039000000600110018f0000002102100029000000000012004b00000000010000390000000101004039000005b10020009c000000980000213d0000000100100190000000980000c13d000000400020043f000000200030008c000005bb0000413d00000021010000290000000003010433000000010030008c000002370000a13d000005bb0000013d000005b20010009c000000980000213d000000250200002900000000040204330000004002100039000000400020043f00000002020000390000000003210436000005cb020000410000000000230435000000400200043d000005c10040009c0000074e0000413d000005bf0400004100000000004204350000000404200039000000200500003900000000005404350000000001010433000000240420003900000000001404350000004404200039000000000001004b000007390000613d000000000500001900000000064500190000000007350019000000000707043300000000007604350000002005500039000000000015004b000007320000413d0000001f03100039000005f603300197000000000114001900000000000104350000004401300039000005a00010009c000005a0010080410000006001100210000006d60000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000007490000c13d000005890000013d000005aa0020009c000000980000213d0000002001200039000000400010043f0000000601000029000000000101041a0000000000120435000005cc0010019800000000040000190000077a0000c13d00000022010000290000000000410435000000400300043d000005b20030009c000000980000213d0000004001300039000000400010043f00000002010000390000000002130436000005cd010000410000000000120435000000400100043d000000000004004b000007a70000c13d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b000007720000413d0000064a0000013d000000400100043d000005aa0010009c000000980000213d0000002002100039000000400020043f0000000402000029000000000202041a0000000000210435000000400300043d000005b20030009c000000980000213d00000006020000290000000302200039000000000202041a000000a8022002700000ffff0420018f0000004002300039000000400020043f00000002020000390000000002230436000005b3050000410000000000520435000000800040008c000007c80000413d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b000006770000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b0000079f0000413d000006770000013d000005b20010009c000000980000213d000000240200002900000000020204330000004003100039000000400030043f00000002030000390000000003310436000005ce040000410000000000430435000000000002004b000007ce0000c13d000000400200043d000005bf0400004100000000004204350000000404200039000000200500003900000000005404350000000001010433000000240420003900000000001404350000004404200039000000000001004b000007390000613d000000000500001900000000064500190000000007350019000000000707043300000000007604350000002005500039000000000015004b000007c00000413d000007390000013d0000000001010433000000010240021000000001022001bf000000000121022f000000010410018f000007580000013d0000000001000415000000230110006900000000010000020000000001000415002500000001001d000000400100043d000005aa0010009c000000980000213d00000006030000290000000402300039002000000002001d000000000202041a002100000002001d0000002002100039000000400020043f000000000203041a002300000002001d0000000000210435000000e00100043d002400000001001d000000c00100043d002200000001001d000001600100043d000000ff01100190000009450000c13d0000002101000029000005a702100197000000000100041500000025011000690000000001000002000000230100002900000020011002700000ffff0110018f000000080300002900000000001304350000002401000029000005a7011001970000000a0300002900000000001304350000002201000029000005a701100197000000090300002900000000001304350000000b010000290000000000210435000005c001000041000001000300043d000000400400043d002500000004001d0000000000140435000005a70130019700000004034000390000000000130435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000250b00002900000025057000290000081e0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b0000081a0000c13d000000000006004b0000082b0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000097a0000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000020b04330000001501000029002400000002001d00000000002104350000000001000415002300000001001d000000400100043d002500000001001d000005cf0010009c000000980000213d00000008010000290000000001010433002100000001001d00000010010000290000000001010433001e00000001001d0000000901000029000000000101043300000007020000290000000002020433000900000002001d0000000a020000290000000002020433000100000002001d000001400200043d000005a7042001970000002503000029000001a002300039000000400020043f0000018002300039001800000002001d00000000000204350000016002300039000a00000002001d00000000000204350000014002300039001600000002001d00000000000204350000012002300039001c00000002001d00000000000204350000010002300039001b00000002001d0000000000020435000000e002300039001d00000002001d0000000000020435000000c002300039000300000002001d0000000000020435000000a002300039000800000002001d00000000000204350000008002300039001700000002001d00000000000204350000006002300039001100000002001d00000000000204350000004002300039001300000002001d00000000000204350000000002030436001a00000002001d0000000000020435000005ae02000041000000400300043d002200000003001d0000000000230435000005a70110019700000004023000390000000000120435000005a00030009c000005a001000041000000000103401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005af011001c7000200000004001d0000000002040019167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000220b00002900000022057000290000089f0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b0000089b0000c13d000000000006004b000008ac0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000098b0000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d0000000101000029000005a70110019700000000020b043300000025030000290000000000230435000005ae02000041000000400300043d002200000003001d000000000023043500000004023000390000000000120435000005a00030009c000005a001000041000000000103401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005af011001c70000000202000029167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000220b0000290000002205700029000008e20000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000008de0000c13d000000000006004b000008ef0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000009970000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000010b04330000001a020000290000000000120435000000400200043d000005aa0020009c000000980000213d0000002001200039000000400010043f0000000601000029000000000101041a00000000001204350000003002100270000000ff04200190000000030200002900000000004204350000000902000029000001c002200039000000000202043300000000020204330000003002200270000000ff0220018f0000000803000029000000000023043500000001030000390000000005030019000009210000613d0000000a060000390000000105000039000000010040019000000000076600a9000000010600603900000000055600a9000000010440027200000000060700190000091a0000c13d0000001d040000290000000000540435000000000002004b0000092e0000613d0000000a040000390000000103000039000000010020019000000000054400a9000000010400603900000000033400a900000001022002720000000004050019000009270000c13d0000001b020000290000000000320435000000400200043d000005aa0020009c000000980000213d0000002003200039000000400030043f000000000012043500000098011002700000ffff0110018f0000000a0200002900000000001204350000001a020000290000000002020433000000000002004b000009a30000c13d0000000005000415000000280550008a00000005055002100000001d0300002900000000030304330000000004000019000009b70000013d000000000010043f0000001301000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000201043b000000400100043d000005aa0010009c000000980000213d000000000202041a0000003002200270001e05a70020019b0000002002100039000001600300043d000000400020043f0000000602000029000000000202041a0000000000210435000000ff01300190000009860000613d000000a802200270000000ff0220018f000000000012004b000009860000c13d000001600100043d000000ff0110018f000000000010043f0000001301000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000000000101041a002300000001001d0000001e0000006b000007e70000613d0000001e01000029002200000001001d000009890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000009810000c13d000005890000013d0000001e0000006b000007e70000613d0000001e01000029002400000001001d000007e70000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000009920000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000099e0000c13d000005890000013d0000001e062000b900000000032600d90000001e0030006c000012a30000c13d0000000005000415000000270550008a00000005055002100000001d030000290000000003030433000000000006004b000009b00000c13d0000000004000019000009b70000013d0000000005000415000000270550008a000000050550021000000000046300a900000000066400d9000000000036004b000012a30000c13d0000000505500270000000000504001f00000025050000290000000007050433000000000007004b00000d230000613d0000001b05000029000000000605043300000000057600a900000000087500d9000000000068004b000012a30000c13d000000000005004b00000d230000613d00000000045400d900000011050000290000000000450435000000210000006b000009ce0000613d000013890500008a00000021055000fa000000000045004b000005bb0000413d000000210500002900000000045400a90000138804400039000027100440011a00000013080000290000000000480435000000240040006c0000000105500270000009f80000a13d00000024090000290000001c04000029000000000094043500000000089700a900000000047800d9000000000094004b000012a30000c13d00000000048600a9000000000008004b000009e40000613d00000000078400d9000000000067004b000012a30000c13d000000000002004b00000d230000613d00000000062300a900000000022600d9000000000032004b000012a30000c13d000000000006004b00000d230000613d000000210000006b000005bb0000613d00000000026400d9000005f803500167000027100330011a000000000023004b000005bb0000413d00002710022000c90000000002520019001e0021002001020000002404000029000009fa0000013d0000001c0200002900000000004204350000001e0200002900000016030000290000000000230435000000000001004b00000a010000c13d000000000100001900000a180000013d000000210000006b000005bb0000613d000005f802500167000027100220011a000000000042004b000005bb0000413d00002710024000c9000000000252001900000021022000fa000000000224004b000012a30000413d00000017030000290000000000230435000005f703100129000000000023004b000005bb0000413d00000000012100a90000138801100039000027100110011a00000018020000290000000000120435000000000414004b000012a30000413d0000000002000415000000230220006900000000020000020000000c02000029000000000012043500000010020000290000001e0300002900000000003204350000000d0200002900000000004204350000000e020000290000000002020433000000000032004b0000000502000029002500030020003d00000a560000c13d000000400300043d000005b20030009c000000980000213d0000002501000029000000000101041a000000a8011002700000ffff0110018f0000004002300039000000400020043f00000002020000390000000002230436000005b3040000410000000000420435000000800010008c00000a4c0000413d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b00000a440000413d0000064a0000013d0000000101100210000005f9011002df0000000403000029000000000203041a000000000112016f000000000013041b0000000c0100002900000000010104330000000d020000290000000004020433000000000041001a000012a30000413d000000000141001900000015020000290000000002020433000000000021004b00000a980000c13d000000400300043d000005b20030009c000000980000213d00000006010000290000000301100039000000000101041a000000a8011002700000ffff0110018f0000004002300039000000400020043f00000002020000390000000002230436000005b3040000410000000000420435000000800010008c00000a820000413d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b00000a7a0000413d0000064a0000013d0000000101100210000000020110020f000005f8011001670000000403000029000000000203041a000000000112016f000000000013041b000001000100043d000000c00200043d0000000003000414000005a705200197000005a706100197000005a00030009c000005a003008041000000c001300210000005d0011001c70000800d020000390000000303000039000005d104000041167d16730000040f0000000100200190000005bb0000613d0000000001000415002400000001001d000000100100002900000000010104330000000f020000290000000002020433000000000012004b00000b490000813d000000000002004b000000000300001900000af80000613d000000070100002900000000010104330000022003100039000000000303043300000140011000390000000001010433000000400600043d002300000006001d0000004404600039000001000500043d000000000014043500000024016000390000000000210435000005d2010000410000000000160435000005a70150019700000004026000390000000000120435000005a00060009c000005a001000041000000000106401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005d3011001c7000005a702300197167d16730000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000230b000029000000230570002900000ad10000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000acd0000c13d000000000006004b00000ade0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000000010020019000000ce80000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000010b043300000007020000290000000002020433000000200220003900000000001204350000000f01000029000000000301043300000010010000290000000001010433000000000013004b000012a30000213d00000000013100490000000702000029000000000202043300000200022000390000000002020433000000400500043d002200000005001d0000002403500039000001000400043d0000000000130435000005d4010000410000000001150436002300000001001d000005a70140019700000004035000390000000000130435000005a00050009c000005a001000041000000000105401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005d5011001c7000005a702200197167d16730000040f0000006003100270000005a003300197000000400030008c000000400400003900000000040340190000001f0640018f0000006007400190000000220b000029000000220570002900000b240000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000b200000c13d000000000006004b00000b310000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000000010020019000000cf40000613d0000001f01400039000000e00210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000400030008c000005bb0000413d00000000010b04330000002302000029000000000202043300000007030000290000000003030433000000a0043000390000000000240435000000c00230003900000b970000013d000000070200002900000000020204330000022003200039000000000303043300000140022000390000000002020433000000400600043d002300000006001d0000004404600039000001000500043d000000000024043500000024026000390000000000120435000005d2010000410000000000160435000005a70150019700000004026000390000000000120435000005a00060009c000005a001000041000000000106401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005d3011001c7000005a702300197167d16730000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000230b000029000000230570002900000b770000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000b730000c13d000000000006004b00000b840000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000000010020019000000d000000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000000010b043300000007020000290000000002020433000000200220003900000000001204350000000001000415000000240110006900000000010000020000000001000415002200000001001d000000400100043d002300000001001d000005c50010009c000000980000213d0000001001000029000000000201043300000007010000290000000005010433000000e00100043d00000023040000290000008003400039000000400030043f000000600340003900000000000304350000004006400039001d00000006001d00000000000604350000000004040436001c00000004001d000000000004043500000020045000390000000004040433002400000005001d0000014005500039001e00000005001d0000000005050433000000000005004b00000bbc0000613d000005bb06500129000000000046004b000005bb0000413d00000000044500a9000005bc0440009a000005bd0740012a0000000000730435000000400400043d000005d60040009c000000980000213d000005a706100197000000050100002900000008031000390000000701100039000000000101041a000000000803041a0000002405000029000000c0035000390000000009030433000000a003500039000000000a030433000001a003500039000000000b030433000001e00350003900000000030304330000012005400039000000400050043f000005a70530019700000100034000390000000000530435000000e005400039002100000006001d0000000000650435000000c0064000390000000000b60435000000a00b4000390000000000ab0435000000800a40003900000000007a043500000060074000390000000000970435000000200940003900000000002904350000008002800270000000000024043500000040024000390000000000020435000005d708000041000000400c00043d001a0000000c001d00000000088c0436001b00000008001d00000000040404330000000408c00039000000000048043500000000040904330000002408c00039000000000048043500000000020204330000004404c00039000000000024043500000000020704330000006404c00039000000000024043500000000020a04330000008404c00039000000000024043500000000020b0433000000a404c0003900000000002404350000000002060433000000c404c0003900000000002404350000000002050433000005a702200197000000e404c0003900000000002404350000000002030433000005a7022001970000010403c000390000000000230435000005a000c0009c000005a00200004100000000020c401900000040022002100000000003000414000005a00030009c000005a003008041000000c003300210000000000323019f000005a702100197000005d8013001c7167d16780000040f0000006003100270000005a003300197000000600030008c000000600400003900000000040340190000001f0640018f00000060074001900000001a0b0000290000001a0570002900000c260000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000c220000c13d000000000006004b00000c330000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000000010020019000000d0c0000613d0000001f01400039000000e00210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000600030008c000005bb0000413d0000001b01000029000000000201043300000000010b04330000004003b0003900000000030304330000001d0400002900000000003404350000001c04000029000000000024043500000023040000290000000000140435000005b70010009c00000e430000813d000000800410021000000005050000290000000105500039000000000605041a000005ba06600197000000000446019f000000000045041b000005ba0020009c00000e430000213d0000002505000029000000000405041a000005d904400197000000000424019f000000000045041b000005ba0030009c00000e430000213d00000005040000290000000204400039000000000504041a000005ba055001970000008006300210000000000565019f000000000054041b0000002404000029000001000440003900000000040404330000001e050000290000000005050433000000400600043d000000800760003900000000005704350000006005600039000000000045043500000040046000390000000000340435000000200360003900000000002304350000000000160435000005a00060009c000005a00600804100000040016002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005da011001c70000800d020000390000000203000039000005db040000410000002105000029167d16730000040f0000000100200190000005bb0000613d0000000001000415000000220110006900000000010000020000000001000415002300000001001d000000400100043d000005aa0010009c000000980000213d00000010020000290000000002020433002400000002001d00000007020000290000000002020433002200000002001d0000002002100039000000400020043f0000000402000029000000000202041a0000000000210435000005dc01200197000000010210008a000000000321013f000000000023004b00000d710000a13d0000000002100089000000000121016f000000000300001900000000020300190000000103300039000000020110027200000ca00000c13d000000000020043f0000001f01000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000000000101041a000005a701100197002500000001001d000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000400200043d000005aa0020009c000000980000213d000000000101043b0000002003200039000000400030043f000000000101041a0000000000120435000005dd0010019800000d710000613d0000002501000029000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b0000002202000029000001c002200039000000000202043300000000020204330000003002200270000000ff0220018f000000020220008c000012a30000413d0000004d0020008c000012a30000213d0000000901100039000000000101041a000000000002004b00000d180000c13d000000010300003900000d290000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000cef0000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000cfb0000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000d070000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000d130000c13d000005890000013d0000000a040000390000000103000039000000010020019000000000054400a9000000010400603900000000033400a90000000102200272000000000405001900000d1a0000c13d000000000003004b00000d290000c13d000005f501000041000000000010043f0000001201000039000000040010043f000005af010000410000167f0001043000000024023000f9000005ba0020009c00000e430000213d000005ba01100197002400000021005300000d4d0000a13d0000002401000029000005ba0010009c000012a30000213d0000002501000029000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b0000000901100039000000000201041a000005d9022001970000002403000029000000000232019f000000000021041b000000400100043d0000000000310435000005a00010009c000005a0010080410000004001100210000000000200041400000d650000013d0000002501000029000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b0000000901100039000000000201041a000005d902200197000000000021041b000000400100043d0000000000010435000005a00010009c000005a00100804100000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005de011001c70000800d020000390000000203000039000005df040000410000002505000029167d16730000040f0000000100200190000005bb0000613d000000000100041500000023011000690000000001000002002601200000003d000001200100043d0000000002000415001c00000002001d000000000001004b0000000601000029001e00010010003d00000e570000c13d0000000601000029167d138f0000040f00000000020100190000000601000029002500000002001d167d14f00000040f0000000001000415002300000001001d000000400100043d002400000001001d000005c50010009c000000980000213d0000000d010000290000000002010433000000c00100043d00000024040000290000008003400039000000400030043f000000600340003900000000000304350000004005400039002000000005001d00000000000504350000000004040436001f00000004001d00000000000404350000002505000029000000200450003900000000040404330000014005500039002100000005001d0000000005050433000000000005004b00000da10000613d000005bb06500129000000000046004b000005bb0000413d00000000044500a9000005bc0440009a000005bd0740012a0000000000730435000000400400043d000005d60040009c000000980000213d000005a706100197000000060100002900000008031000390000000701100039000000000101041a000000000803041a0000002505000029000000c0035000390000000009030433000000a003500039000000000a030433000001a003500039000000000b030433000001e00350003900000000030304330000012005400039000000400050043f000005a70530019700000100034000390000000000530435000000e005400039002200000006001d0000000000650435000000c0064000390000000000b60435000000a00b4000390000000000ab0435000000800a40003900000000007a04350000006007400039000000000097043500000040094000390000000000290435000000800280027000000000022404360000000000020435000005d708000041000000400c00043d001b0000000c001d00000000088c0436001d00000008001d00000000040404330000000408c00039000000000048043500000000020204330000002404c00039000000000024043500000000020904330000004404c00039000000000024043500000000020704330000006404c00039000000000024043500000000020a04330000008404c00039000000000024043500000000020b0433000000a404c0003900000000002404350000000002060433000000c404c0003900000000002404350000000002050433000005a702200197000000e404c0003900000000002404350000000002030433000005a7022001970000010403c000390000000000230435000005a000c0009c000005a00200004100000000020c401900000040022002100000000003000414000005a00030009c000005a003008041000000c003300210000000000323019f000005a702100197000005d8013001c7167d16780000040f0000006003100270000005a003300197000000600030008c000000600400003900000000040340190000001f0640018f00000060074001900000001b0b0000290000001b0570002900000e0a0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000e060000c13d000000000006004b00000e170000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000000010020019000000ffe0000613d0000001f01400039000000e00210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000600030008c000005bb0000413d0000001d01000029000000000201043300000000010b04330000004003b000390000000003030433000000200400002900000000003404350000001f04000029000000000024043500000024040000290000000000140435000005ba0010009c00000e430000213d00000080041002100000001e06000029000000000506041a000005ba05500197000000000445019f000000000046041b000005ba0020009c00000e430000213d00000006040000290000000304400039000000000504041a000005d905500197000000000525019f000000000054041b000005ba0030009c0000100a0000a13d000000400100043d0000006402100039000005f30300004100000000003204350000004402100039000005f4030000410000000000320435000000240210003900000027030000390000000000320435000005bf020000410000000000210435000000040210003900000020030000390000000000320435000005a00010009c000005a0010080410000004001100210000005ea011001c70000167f000104300000000b010000290000000002010433000000400400043d002400000004001d000005c00100004100000000001404350000000001000411000005a7031001970000000401400039002100000003001d0000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000240b000029000000240570002900000e7e0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000e7a0000c13d000000000006004b00000e8b0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000010750000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d0000000d010000290000000001010433002500000001001d00000000010b0433002400000001001d0000000b010000290000000001010433000001000200043d002200000002001d000005e0020000410000000000200443000005a701100197002300000001001d00000004001004430000000001000414000005a00010009c000005a001008041000000c001100210000005e1011001c70000800202000039167d16780000040f0000000100200190000013720000613d000000000101043b000000000001004b000005bb0000613d0000002201000029000005a701100197000000400400043d000000440240003900000025030000290000000000320435000000240240003900000021030000290000000000320435000005e202000041000000000024043500000004024000390000000000120435000005a00040009c002500000004001d000005a001000041000000000104401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005d3011001c70000002302000029167d16730000040f0000000100200190000010810000613d0000002501000029000005b10010009c000000980000213d0000002501000029000000400010043f000000240000006b000011450000c13d0000002101000029000000000010043f0000001401000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b001d00000001001d000000400100043d002300000001001d000005aa0010009c000000980000213d0000002001000029000000000101041a00000023030000290000002002300039000000400020043f0000000602000029000000000202041a00000000002304350000000002000415002200000002001d0000000002030433000005dd0020019800000fee0000613d000005a702100197000000400300043d002400000003001d000005e3010000410000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000240b000029000000240570002900000f170000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00000f130000c13d000000000006004b00000f240000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000108e0000613d0000001f01400039000000600110018f0000000002b10019000000000012004b00000000010000390000000101004039002500000002001d000005b10020009c000000980000213d0000000100100190000000980000c13d0000002501000029000000400010043f000000200030008c000005bb0000413d00000000020b0433000005a70020009c000005bb0000213d000005e40100004100000025030000290000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000250570002900000f550000613d000000000801034f0000002509000029000000008a08043c0000000009a90436000000000059004b00000f510000c13d000000000006004b00000f620000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000109a0000613d0000001f01400039000000600110018f0000002501100029002400000001001d000005b10010009c000000980000213d0000002401000029000000400010043f000000200030008c000005bb0000413d00000025010000290000000002010433000005a70020009c000005bb0000213d000005e50100004100000024030000290000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000240570002900000f8f0000613d000000000801034f0000002409000029000000008a08043c0000000009a90436000000000059004b00000f8b0000c13d000000000006004b00000f9c0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000010a60000613d0000001f01400039000000600110018f0000002401100029002500000001001d000005b10010009c000000980000213d0000002501000029000000400010043f000000200030008c000005bb0000413d00000024010000290000000002010433000005a70020009c000005bb0000213d0000002504000029000000240140003900000021030000290000000000310435000005e60100004100000000001404350000000401400039000005e7030000410000000000310435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005d5011001c7167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000250570002900000fcf0000613d000000000801034f0000002509000029000000008a08043c0000000009a90436000000000059004b00000fcb0000c13d000000000006004b00000fdc0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000010b20000613d0000001f01400039000000600110018f0000002501100029000005b10010009c000000980000213d000000400010043f000000200030008c000005bb0000413d00000025010000290000000001010433000000010010008c000005bb0000213d000000000001004b0000112d0000613d000000230100002900000000020104330000ffff002001900000112d0000613d000000400100043d000005aa0010009c000000980000213d0000002002100039000000400020043f0000001d02000029000000000202041a0000000000210435000005dc01200198000010be0000c13d000000000100041500000022011000690000000001000002000010fb0000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000010050000c13d000005890000013d00000006040000290000000204400039000000000504041a000005ba055001970000008006300210000000000565019f000000000054041b0000002104000029000000000404043300000025050000290000010005500039002500000005001d0000000005050433000000400600043d000000800760003900000000004704350000006004600039000000000054043500000040046000390000000000340435000000200360003900000000002304350000000000160435000005a00060009c000005a00600804100000040016002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005da011001c70000800d020000390000000203000039000005db040000410000002205000029167d16730000040f0000000100200190000005bb0000613d00000000010004150000002301100069000000000100000200000025010000290000000001010433002300000001001d0000000d010000290000000001010433002500000001001d0000000b010000290000000001010433000001000200043d002200000002001d000005e0020000410000000000200443000005a701100197002400000001001d00000004001004430000000001000414000005a00010009c000005a001008041000000c001100210000005e1011001c70000800202000039167d16780000040f0000000100200190000013720000613d000000000101043b000000000001004b000005bb0000613d0000002201000029000005a701100197000000400400043d0000006402400039000000230300002900000000003204350000004402400039000000250300002900000000003204350000000002000411000005a70220019700000024034000390000000000230435000005e902000041000000000024043500000004024000390000000000120435000005a00040009c002500000004001d000005a001000041000000000104401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005ea011001c70000002402000029167d16730000040f0000000100200190000011200000613d0000002501000029000005b10010009c000000980000213d0000002501000029000000400010043f000011450000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000107c0000c13d000005890000013d00000060061002700000001f0460018f000005b005600198000000400200043d00000000035200190000137f0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000038004b000010890000c13d0000137f0000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000010950000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000010a10000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000010ad0000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000010b90000c13d000005890000013d000000400300043d000005aa0030009c000000980000213d0000002004300039000000400040043f0000000000230435000000010210008a000000000321013f000000000023004b000010f40000a13d0000000002100089000000000121016f0000000003000019000000000203001900000001033000390000000201100272000010cb0000c13d000000000020043f0000001f01000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000000101043b000000000101041a000005a701100197000000000010043f0000001901000029000000200010043f0000000001000414000005a00010009c000005a001008041000000c001100210000005ab011001c70000801002000039167d16780000040f0000000100200190000005bb0000613d000000400200043d000005aa0020009c000000980000213d000000000101043b0000002003200039000000400030043f000000000101041a0000000000120435000005dd001001980000112d0000c13d00000023010000290000000001010433000000000200041500000022022000690000000002000002000005dd00100198000011450000c13d000000400300043d000005b20030009c000000980000213d00000006010000290000000301100039000000000101041a000000a8011002700000ffff0110018f0000004002300039000000400020043f00000002020000390000000002230436000005b3040000410000000000420435000000800010008c000011310000413d000000400100043d000005bf0400004100000000004104350000000404100039000000200500003900000000005404350000000003030433000000240410003900000000003404350000004404100039000000000003004b0000064a0000613d000000000500001900000000064500190000000007250019000000000707043300000000007604350000002005500039000000000035004b000011180000413d0000064a0000013d00000060061002700000001f0460018f000005b005600198000000400200043d00000000035200190000137f0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000038004b000011280000c13d0000137f0000013d000000000100041500000022011000690000000001000002000011450000013d0000000101100210000000020110020f0000001d03000029000000000203041a000000000112019f000000000013041b000000c00100043d0000000002000414000005a705100197000005a00020009c000005a002008041000000c001200210000005d0011001c70000800d020000390000000303000039000005e8040000410000000006000411167d16730000040f0000000100200190000005bb0000613d00000000010004150000001c0110006900000000010000020000000c010000290000000001010433000000000001004b000012650000613d00000006010000290000000301100039000000000101041a002500000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000013720000613d00000025020000290000008002200270000005b6032001970000001e02000029000000000202041a002500000002001d000000000101043b002400000003001d000000000013004b000011680000c13d0000002501000029000005ba01100197000011890000013d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000013720000613d000000000101043b000000240110006c000012a30000413d0000002504000029000000800340027000000000023100a9000005b70040009c0000117e0000413d00000000033200d9000000000013004b000012a30000c13d000005b80120012a000005b90110009a0000002502000029000005ba02200198000011860000613d000005bb03200129000000000013004b000005bb0000413d00000000012100a9000005bc0110009a000005bd0110012a002400000001001d000000240000006b000005bb0000613d00000024010000290023000100100278000000010100008a000000230110014f0000000c020000290000000002020433000005bd0110012a002200000002001d000000000021004b000005bb0000413d0000000b010000290000000002010433000001000100043d000000400400043d002100000004001d000005be030000410000000000340435000005a70110019700000004034000390000000000130435000005a00040009c000005a001000041000000000104401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005af011001c7000005a702200197167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000210b0000290000002105700029000011bc0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000011b80000c13d000000000006004b000011c90000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000012a90000613d0000001f01400039000000600110018f0000000002b10019000000000012004b00000000010000390000000101004039002500000002001d000005b10020009c000000980000213d0000000100100190000000980000c13d0000002501000029000000400010043f000000200030008c000005bb0000413d0000002201000029000005bd011000d1000000230110002900000024021000fa00000000010b0433000000000012004b000011ec0000a13d0000002402000029000005bb02200129000000000012004b000005bb0000413d00000024011000b9000005bc0110009a000005bd0110012a0000000c020000290000000000120435000000400100043d002500000001001d0000000b010000290000000002010433000001000100043d002300000001001d000005eb010000410000002503000029002500000003001d0000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7000005a702200197002400000002001d167d16780000040f0000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f00000020074001900000002505700029000012100000613d000000000801034f0000002509000029000000008a08043c0000000009a90436000000000059004b0000120c0000c13d000000000006004b0000121d0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f00000000006504350000000100200190000012b50000613d0000001f01400039000000600210018f0000002501200029000000000021004b00000000020000390000000102004039000005b10010009c000000980000213d0000000100200190000000980000c13d000000400010043f000000200030008c000005bb0000413d00000025010000290000000001010433002500000001001d000005a70010009c000005bb0000213d0000000c010000290000000001010433002200000001001d000005e0010000410000000000100443000000240100002900000004001004430000000001000414000005a00010009c000005a001008041000000c001100210000005e1011001c70000800202000039167d16780000040f0000000100200190000013720000613d000000000101043b000000000001004b000005bb0000613d0000002301000029000005a701100197000000400400043d000000440240003900000022030000290000000000320435000000240240003900000025030000290000000000320435000005e202000041000000000024043500000004024000390000000000120435000005a00040009c002500000004001d000005a001000041000000000104401900000040011002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005d3011001c70000002402000029167d16730000040f0000000100200190000012c10000613d0000002501000029000005b10010009c000000980000213d0000002501000029000000400010043f00000007010000290000000001010433000001e001100039000000000101043300000010020000290000000002020433000000e00300043d0000000004000415002400000004001d000000400400043d00000044054000390000000000250435000005a70110019700000024024000390000000000120435000005ec0100004100000000001404350000000001000411000005a7021001970000000401400039002500000002001d0000000000210435000005a00040009c000005a00400804100000040014002100000000002000414000005a00020009c000005a002008041000000c002200210000000000112019f000005a702300197000005d3011001c7002300000002001d167d16730000040f00000060031002700000000100200190000012ce0000613d000005a002300198000012e70000613d000000200020008c000013010000c13d000000000101043b000000000010043f000000000001004b0000130b0000c13d000000400100043d0000004402100039000005ed030000410000000000320435000000240210003900000019030000390000000000320435000005bf020000410000000000210435000000040210003900000020030000390000000000320435000005a00010009c000005a0010080410000004001100210000005d3011001c70000167f00010430000005f501000041000000000010043f0000001101000039000000040010043f000005af010000410000167f000104300000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000012b00000c13d000005890000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000005890000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000012bc0000c13d000005890000013d00000060061002700000001f0460018f000005b005600198000000400200043d00000000035200190000137f0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000038004b000012c90000c13d0000137f0000013d0000001f0430018f000005b002300198000012d70000613d000000000501034f0000000006000019000000005705043c0000000006760436000000000026004b000012d30000c13d000005a003300197000000000004004b000012e50000613d000000000121034f0000000304400210000000000502043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f000000000012043500000060013002100000167f00010430000005e0010000410000000000100443000000230100002900000004001004430000000001000414000005a00010009c000005a001008041000000c001100210000005e1011001c70000800202000039167d16780000040f0000000100200190000013720000613d000000000101043b000000000001004b0000130b0000c13d000005bf01000041000000000010043f0000002001000039000000040010043f0000001401000039000000240010043f000005f101000041000000440010043f000005d3010000410000167f00010430000005bf01000041000000000010043f0000002001000039000000040010043f0000001f01000039000000240010043f000005f201000041000000440010043f000005d3010000410000167f0001043000000000010004150000002401100069000000000100000200000010010000290000000001010433002400000001001d00000007010000290000000001010433000001e0011000390000000001010433000001000200043d002200000002001d000005e0020000410000000000200443000005a701100197002300000001001d00000004001004430000000001000414000005a00010009c000005a001008041000000c001100210000005e1011001c70000800202000039167d16780000040f0000000100200190000013720000613d000000000101043b000000000001004b000005bb0000613d0000002201000029000005a701100197000000400300043d00000044023000390000002404000029000000000042043500000024023000390000000000120435000005ee010000410000000001130436002100000001001d000000040130003900000025020000290000000000210435000005a00030009c002400000003001d000005a001000041000000000103401900220040001002180000000001000414000005a00010009c000005a001008041000000c00110021000000022011001af000005d3011001c70000002302000029167d16730000040f0000000100200190000013730000613d0000002401000029000005b10010009c000000980000213d0000002409000029000000400090043f00000026010000290000000001010433000000100200002900000000020204330000000d0300002900000000030304330000004004900039000001000700043d000000e00600043d000000c00500043d000000250800002900000000008404350000002104000029000000000034043500000000002904350000006002900039000000000001004b0000000001000039000000010100c03900000000001204350000000001000414000005a00010009c000005a001008041000000c00110021000000022011001af000005a705500197000005a706600197000005a707700197000005ef011001c70000800d020000390000000403000039000005f004000041167d16730000040f0000000100200190000005bb0000613d00000000010004150000001201100069000000000100000200000000010000190000167e0001042e000000000001042f00000060061002700000001f0460018f000005b005600198000000400200043d00000000035200190000137f0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000038004b0000137b0000c13d000005a006600197000000000004004b0000138d0000613d000000000151034f0000000304400210000000000503043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f00000000001304350000006001600210000005970000013d000a000000000002000000400200043d000005fa0020009c000014be0000813d0000028003200039000000400030043f000001a00320003900000000000304350000018003200039000000000003043500000160032000390000000000030435000001400320003900000000000304350000012003200039000000000003043500000100032000390000000000030435000000e0032000390000000000030435000000c0032000390000000000030435000000a0032000390000000000030435000000800320003900000000000304350000006003200039000000000003043500000040032000390000000000030435000000200320003900000000000304350000000000020435000000400300043d000005aa0030009c000014be0000213d0000002004300039000000400040043f0000000000030435000001c004200039000000000034043500000260032000390000000000030435000002400320003900000000000304350000022003200039000000000003043500000200032000390000000000030435000001e0022000390000000000020435000000400e00043d000005a900e0009c000014be0000213d0000028002e00039000000400020043f000001a006e0003900000000000604350000018002e0003900000000000204350000016003e0003900000000000304350000014004e0003900000000000404350000012005e0003900000000000504350000010007e000390000000000070435000000e008e000390000000000080435000000c009e00039000600000009001d0000000000090435000000a009e00039000500000009001d00000000000904350000008009e00039000400000009001d00000000000904350000006009e00039000200000009001d00000000000904350000004009e00039000300000009001d000000000009043500000000090e0436000700000009001d0000000000090435000000400900043d000005aa0090009c000014be0000213d000000200a9000390000004000a0043f0000000000090435000001c00ce0003900000000009c04350000026009e00039000100000009001d00000000000904350000024009e000390000000000090435000002200ae0003900000000000a0435000002000fe0003900000000000f0435000001e00be0003900000000000b0435000000400d00043d000005aa00d0009c000014be0000213d000a0000000e001d000000200ed000390000004000e0043f000000000e01041a0000000000ed04350000000000dc0435000000000c0d0433000000400cc002700000ffff0cc0018f0000000000c604350000000106100039000000000606041a000005ba0c6001970000000000c704350000000000c804350000000207100039000000000707041a000005ba087001970000000000840435000000000085043500000080046002700000000000430435000000800370027000000000003204350000000402100039000000000202041a000005a70220019700000000002b04350000000502100039000000000202041a000005a70220019700090000000f001d00000000002f04350000000602100039000000000202041a000005a70220019700000000002a04350000000301100039000000000101041a0000008001100270000005b6011001970000000000190435000005fb01000041000000400300043d000800000003001d0000000000130435000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7167d16780000040f000000080b0000290000006003100270000005a003300197000000200030008c000000200400003900000000040340190000001f0640018f000000200740019000000000057b0019000014460000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000014420000c13d000000000006004b000014530000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000000a050000290000000906000029000014c60000613d0000001f01400039000000600210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000014be0000213d0000000100200190000014be0000c13d000000400010043f0000001f0030008c000014c40000a13d00000000010b04330000000702000029000000000012043500000000001504350000000002060433000000400300043d000900000003001d000005fc010000410000000001130436000800000001001d000005a00030009c000005a001000041000000000103401900000040011002100000000003000414000005a00030009c000005a003008041000000c003300210000000000113019f000005c9011001c7000005a702200197167d16780000040f000000090b0000290000006003100270000005a003300197000000800030008c000000800400003900000000040340190000001f0640018f000000e00740019000000000057b00190000148a0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b000014860000c13d000000000006004b000014970000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f000000000065043500000001002001900000000a05000029000014d20000613d0000001f01400039000001e00210018f0000000001b20019000000000021004b00000000020000390000000102004039000005b10010009c000014be0000213d0000000100200190000014be0000c13d000000400010043f000000800030008c000014c40000413d0000006001b000390000000001010433000005b60010009c000014c40000213d0000000802000029000000000202043300000000030b04330000004004b0003900000000040404330000000106000029000000000016043500000002010000290000000000410435000000040100002900000000002104350000000301000029000000000031043500000006010000290000000000210435000000050100002900000000004104350000000001050019000000000001042d000005f501000041000000000010043f0000004101000039000000040010043f000005af010000410000167f0001043000000000010000190000167f000104300000001f0530018f000005b006300198000000400200043d0000000004620019000014dd0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000014cd0000c13d000014dd0000013d0000001f0530018f000005b006300198000000400200043d0000000004620019000014dd0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000014d90000c13d000000000005004b000014ea0000613d000000000161034f0000000305500210000000000604043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f00000000001404350000006001300210000005a00020009c000005a0020080410000004002200210000000000112019f0000167f00010430000c000000000002000c00000002001d000a00000001001d0000000301100039000900000001001d000000000101041a000b00000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000015fc0000613d000000000101043b000005b6021001970000000b010000290000008001100270000005b601100197000b00000002001d000000000021004b000015fb0000613d0000000c0400002900000160014000390000000001010433000000000001004b0000024005400039000800000005001d000015400000613d000600000001001d0000000001050433000700000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000015fc0000613d000000000101043b0000000702000029000005b602200197000000000221004b0000000c04000029000015fd0000413d00000006012000b900000006031000fa000000000023004b000015fd0000c13d000005b80110012a000005b90110009a000000e0024000390000000002020433000000000002004b0000000805000029000015330000613d000005bb03200129000000000013004b000016030000413d00000000011200a9000005bc0210009a0000010003400039000005bd0120012a0000000000130435000005fd0020009c000016050000813d0000000a020000290000000102200039000000000302041a000005d903300197000000000113019f000000000012041b0000000001040433000000000001004b00000120084000390000014007400039000015720000613d000600000008001d000700000007001d0000000001050433000500000001001d00000180014000390000000001010433000400000001001d000005b40100004100000000001004430000000001000414000005a00010009c000005a001008041000000c001100210000005b5011001c70000800b02000039167d16780000040f0000000100200190000015fc0000613d000000000301043b0000000501000029000005b6021001970000000401000029167d161f0000040f00000006080000290000000002080433000000000002004b0000000c0400002900000008050000290000000707000029000015660000613d000005bb03200129000000000013004b000016030000413d00000000011200a9000005bc0210009a000005bd0120012a0000000000170435000005fe0020009c000016050000213d0000000a020000290000000202200039000000000302041a000005d903300197000000000113019f000000000012041b0000000006000415000000400a00043d000005ff00a0009c000016190000813d000000c001a00039000000400010043f000000a002a0003900000000000204350000008003a000390000000000030435000000600da0003900000000000d0435000000400ca0003900000000000c0435000000000b0a043600000000000b0435000001a0094000390000000001090433000000000001004b000015f10000613d00070000000d001d00050000000a001d000600000009001d000200000003001d000100000002001d00000000010404330000000002080433000000000002004b000015920000613d000005bb03200129000000000013004b000016030000413d00000000011200a9000005bc0110009a000005bd0110012a00000000001b043500000000010404330000000002070433000000000002004b0000159d0000613d000005bb03200129000000000013004b000016030000413d00000000011200a9000005bc0110009a000005bd0110012a00000000001c043500000060014000390000000001010433000000000305043300000260024000390000000002020433000005b602200197000005b603300197000800000006001d00040000000b001d00030000000c001d167d161f0000040f0000000305000029000000040700002900000008060000290000000c040000290000000702000029000000000012043500000040024000390000000002020433000000000001004b000015b90000613d000005bb03100129000000000023004b000016030000413d00000000011200a9000005bc0110009a000005bd0110012a00000005020000290000000000120435000000000205043300000080034000390000000003030433000000000023001a0000000605000029000015fd0000413d00000000022300190000000003070433000000000232004b000015fd0000413d000000000112004b000015fd0000413d000000020200002900000000001204350000000002050433000000000002004b000015d20000613d000005f703200129000000000013004b000016030000413d00000000011200a90000138802100039000027100120011a00000001030000290000000000130435000027100020008c000015f10000413d00000100024000390000000002020433000000000002004b000016030000613d0000000103200270000005f804300167000005bd0440012a000000000014004b000016030000413d000005bd011000d1000000000113001900000000022100d9000005ba0020009c000016050000213d0000000a010000290000000801100039000000000301041a000005ba043001970000000002240019000005ba0020009c000015fd0000213d000005d903300197000000000232019f000000000021041b0000000001000415000000000116004900000000010000020000000b0100002900000080011002100000000903000029000000000203041a0000060002200197000000000112019f000000000013041b000000000001042d000000000001042f000005f501000041000000000010043f0000001101000039000000040010043f000005af010000410000167f0001043000000000010000190000167f00010430000000400100043d0000006402100039000005f30300004100000000003204350000004402100039000005f4030000410000000000320435000000240210003900000027030000390000000000320435000005bf020000410000000000210435000000040210003900000020030000390000000000320435000005a00010009c000005a0010080410000004001100210000005ea011001c70000167f00010430000005f501000041000000000010043f0000004101000039000000040010043f000005af010000410000167f000104300002000000000002000005b602200197000000000323004b0000166c0000413d000005bd02000041000016650000613d0000000006000415000000020660008a0000000506600210000000020230008c000000000200a019000000000001004b000016390000613d000005bb04100129000000000014004b000016370000413d0000000006000415000000010660008a000000050660021000000000051100a9000005bc0550009a000006010550012a000000000054004b0000163a0000813d00000000010000190000167f000104300000000005000019000000010730008a00000000041500a9000005bc0440009a000006020440012a0000000506600270000000000604001f00000000063700a900000000083600d9000000000078004b0000166c0000c13d000000000006004b000016560000613d00000000076500a900000000086700d9000000000058004b0000166c0000c13d00000000086200a900000000056800d9000000000025004b0000166c0000c13d0000000102700270000000000008004b000016670000613d00000000058400a900000000068500d9000000000046004b0000165a0000613d0000166c0000013d000000000007004b0000166c0000c13d0000000002000019000000000500001900000000041300a9000000000001004b000016600000613d00000000011400d9000000000031004b0000166c0000c13d000000060150011a000005b80340012a00000000022300190000000001120019000005b90210009a0000000001020019000000000001042d000000000500001900000000041300a9000000000001004b0000165d0000c13d000016600000013d000005f501000041000000000010043f0000001101000039000000040010043f000005af010000410000167f00010430000000000001042f00001676002104210000000102000039000000000001042d0000000002000019000000000001042d0000167b002104230000000102000039000000000001042d0000000002000019000000000001042d0000167d000004320000167e0001042e0000167f0001043000000000000000000000000000000000000000000000000000000000ffffffff000000020000000000000000000000000000008000000100000000000000000000000000000000000000000000000000000000000000000000000000d246754400000000000000000000000000000000000000000000000000000000a18964a50000000000000000000000000000000000000000000000000000000083c1087d00000000000000000000000000000000000000200000008000000000000000000000000000000000000000000000000000000000000000000d2f13f7789f0000000000000000000000000000ffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000fffffffffffffe80000000000000000000000000000000000000000000000000fffffffffffffd7f000000000000000000000000000000000000000000000000ffffffffffffffdf0200000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff5f000000000000000000000000000000000000000000000000fffffffffffffd9fb3596f0700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffe0000000000000000000000000000000000000000000000000ffffffffffffffff000000000000000000000000000000000000000000000000ffffffffffffffbf3734000000000000000000000000000000000000000000000000000000000000796b89b91644bc98cd93958e4c9038275d622183e25ac5af08cc6b5d955391320200000200000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffff00000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e13380fffffffffffffffffffffffffffffffffffffffffcc4d1c3602f7fc31800000000000000000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe6268e1b017bfe18bfffffffffffffffffffffffffffffffffffffffffffffffe6268e1b017bfe18c0000000000000000000000000000000000000000000000033b2e3c9fd0803ce80000001da24f3e0000000000000000000000000000000000000000000000000000000008c379a00000000000000000000000000000000000000000000000000000000070a08231000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000d2f13f7789f000100068db8bac710cb295e9e1b089a027525460aa64c2f837b4a2339c0ebedfa43000d1b71758e219652bd3c36113404ea4a8c154c985f06f694467381d7dbf486000000000000000000000000000000000000000000000000ffffffffffffff7f323700000000000000000000000000000000000000000000000000000000000032390000000000000000000000000000000000000000000000000000000000007a5d20ea0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000003539000000000000000000000000000000000000000000000000000000000000343500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffff000034360000000000000000000000000000000000000000000000000000000000003437000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffffe5f020000000000000000000000000000000000000000000000000000000000000044c58d81365b66dd4b1a7f36c25aa97b8c71c361ee4937adc1a00000227db5ddf5298aca0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000640000000000000000000000009dc29fac000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000000000000000fffffffffffffedfa5898709000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000124000000000000000000000000ffffffffffffffffffffffffffffffff0000000000000000000000000000000002000000000000000000000000000000000000a0000000000000000000000000804c9b842b2748a22bb64b345453a3de7ca54a6ca45ce00d415894979e22897aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0ffffffffff000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000020000000000000000000000000aef84d3b40895fd58c561f3998000f0583abb992a52fbdc99ace8e8de4d676a51806aa1896bbf26568e884a7374b41e002500962caba6a15023a8d90e8508b830200000200000000000000000000000000000024000000000000000000000000f866c319000000000000000000000000000000000000000000000000000000007535d246000000000000000000000000000000000000000000000000000000000542975c00000000000000000000000000000000000000000000000000000000707cd7160000000000000000000000000000000000000000000000000000000091d1485400000000000000000000000000000000000000000000000000000000d1d2cf869016112a9af1107bcf43c3759daf22cf734aad47d0c9c726e33bc78200058a56ea94653cdf4f152d227ace22d4c00ad99e2a43f58cb7d9e3feb295f2d7020d0a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000084000000000000000000000000ae1673350000000000000000000000000000000000000000000000000000000023b872dd00000000000000000000000000000000000000000000000000000000475076323a206661696c6564207472616e7366657246726f6d000000000000006fd97676000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000080000000000000000000000000e413a321e8681d831f4dbccbca790d2952b56f977908e45be37335533e005286475076323a206e6f74206120636f6e7472616374000000000000000000000000475076323a206d616c666f726d6564207472616e7366657220726573756c7400323820626974730000000000000000000000000000000000000000000000000053616665436173743a2076616c756520646f65736e27742066697420696e20314e487b7100000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec77fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe000000000000000000000000000000000000000000000000fffffffffffffd80b1bf962d00000000000000000000000000000000000000000000000000000000797743380000000000000000000000000000000000000000000000000000000000000000033b2e3c9fd0803ce80000000000000000000000000000000000000000000000033b2e3c9fd0803ce7ffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000ffffffffffffff40ffffffffffffffffffffff0000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000b6aa1293e652c95e1b2855a9a000000000000000000000000000000000000000000000612d847b578e7643c28ac000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a26469706673582212200720d0ab1ce63d4528ea755d5f38af043bc27164adb7f443632dc1b5a65f8dcd64736f6c6378247a6b736f6c633a312e352e31353b736f6c633a302e382e33303b6c6c766d3a312e302e320055