Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {ERC20Upgradeable, ERC20PermitUpgradeable} from 'openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/ERC20PermitUpgradeable.sol';
import {IERC20Metadata} from '@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol';
import {PausableUpgradeable} from 'openzeppelin-contracts-upgradeable/contracts/utils/PausableUpgradeable.sol';
import {IRescuable, Rescuable} from 'solidity-utils/contracts/utils/Rescuable.sol';
import {IRescuableBase, RescuableBase} from 'solidity-utils/contracts/utils/RescuableBase.sol';
import {IERC20Permit} from '@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol';

import {IACLManager} from '../../../contracts/interfaces/IACLManager.sol';
import {ERC4626Upgradeable, ERC4626StataTokenUpgradeable, IPool, Math, IERC20} from './ERC4626StataTokenUpgradeable.sol';
import {ERC20AaveLMUpgradeable, IRewardsController} from './ERC20AaveLMUpgradeable.sol';
import {IStataTokenV2} from './interfaces/IStataTokenV2.sol';
import {IAToken} from './interfaces/IAToken.sol';

/**
 * @title StataTokenV2
 * @notice A 4626 Vault which wrapps aTokens in order to translate the rebasing nature of yield accrual into a non-rebasing value accrual.
 * @author BGD labs
 */
contract StataTokenV2 is
  ERC20PermitUpgradeable,
  ERC20AaveLMUpgradeable,
  ERC4626StataTokenUpgradeable,
  PausableUpgradeable,
  Rescuable,
  IStataTokenV2
{
  using Math for uint256;

  constructor(
    IPool pool,
    IRewardsController rewardsController
  ) ERC20AaveLMUpgradeable(rewardsController) ERC4626StataTokenUpgradeable(pool) {
    _disableInitializers();
  }

  modifier onlyPauseGuardian() {
    if (!canPause(_msgSender())) revert OnlyPauseGuardian(_msgSender());
    _;
  }

  function initialize(
    address aToken,
    string calldata staticATokenName,
    string calldata staticATokenSymbol
  ) external initializer {
    __ERC20_init(staticATokenName, staticATokenSymbol);
    __ERC20Permit_init(staticATokenName);
    __ERC20AaveLM_init(aToken);
    __ERC4626StataToken_init(aToken);
    __Pausable_init();
  }

  ///@inheritdoc IStataTokenV2
  function setPaused(bool paused) external onlyPauseGuardian {
    if (paused) _pause();
    else _unpause();
  }

  /// @inheritdoc Rescuable
  function whoCanRescue() public view override returns (address) {
    return POOL_ADDRESSES_PROVIDER.getACLAdmin();
  }

  /// @inheritdoc IRescuableBase
  function maxRescue(
    address asset
  ) public view override(IRescuableBase, RescuableBase) returns (uint256) {
    address cachedAToken = aToken();
    if (asset == cachedAToken) {
      uint256 requiredBacking = _convertToAssets(totalSupply(), Math.Rounding.Ceil);
      uint256 balance = IERC20(cachedAToken).balanceOf(address(this));
      return balance > requiredBacking ? balance - requiredBacking : 0;
    }
    return type(uint256).max;
  }

  ///@inheritdoc IStataTokenV2
  function canPause(address actor) public view returns (bool) {
    return IACLManager(POOL_ADDRESSES_PROVIDER.getACLManager()).isEmergencyAdmin(actor);
  }

  ///@inheritdoc IERC20Permit
  function nonces(
    address owner
  ) public view virtual override(ERC20PermitUpgradeable, IERC20Permit) returns (uint256) {
    return super.nonces(owner);
  }

  ///@inheritdoc IERC20Metadata
  function decimals()
    public
    view
    override(IERC20Metadata, ERC20Upgradeable, ERC4626Upgradeable)
    returns (uint8)
  {
    /// @notice The initialization of ERC4626Upgradeable already assures that decimal are
    /// the same as the underlying asset of the StataTokenV2, e.g. decimals of WETH for stataWETH
    return ERC4626Upgradeable.decimals();
  }

  function _claimRewardsOnBehalf(
    address onBehalfOf,
    address receiver,
    address[] memory rewards
  ) internal virtual override whenNotPaused {
    super._claimRewardsOnBehalf(onBehalfOf, receiver, rewards);
  }

  // @notice to merge inheritance with ERC20AaveLMUpgradeable.sol properly we put
  // `whenNotPaused` here instead of using ERC20PausableUpgradeable
  function _update(
    address from,
    address to,
    uint256 amount
  ) internal virtual override(ERC20AaveLMUpgradeable, ERC20Upgradeable) whenNotPaused {
    ERC20AaveLMUpgradeable._update(from, to, amount);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Permit.sol)

pragma solidity ^0.8.20;

import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {EIP712Upgradeable} from "../../../utils/cryptography/EIP712Upgradeable.sol";
import {NoncesUpgradeable} from "../../../utils/NoncesUpgradeable.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20Permit, EIP712Upgradeable, NoncesUpgradeable {
    bytes32 private constant PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Permit deadline has expired.
     */
    error ERC2612ExpiredSignature(uint256 deadline);

    /**
     * @dev Mismatched signature.
     */
    error ERC2612InvalidSigner(address signer, address owner);

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    function __ERC20Permit_init(string memory name) internal onlyInitializing {
        __EIP712_init_unchained(name, "1");
    }

    function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}

    /**
     * @inheritdoc IERC20Permit
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        if (block.timestamp > deadline) {
            revert ERC2612ExpiredSignature(deadline);
        }

        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        if (signer != owner) {
            revert ERC2612InvalidSigner(signer, owner);
        }

        _approve(owner, spender, value);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    function nonces(address owner) public view virtual override(IERC20Permit, NoncesUpgradeable) returns (uint256) {
        return super.nonces(owner);
    }

    /**
     * @inheritdoc IERC20Permit
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
        return _domainSeparatorV4();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /// @custom:storage-location erc7201:openzeppelin.storage.Pausable
    struct PausableStorage {
        bool _paused;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;

    function _getPausableStorage() private pure returns (PausableStorage storage $) {
        assembly {
            $.slot := PausableStorageLocation
        }
    }

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal onlyInitializing {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        PausableStorage storage $ = _getPausableStorage();
        return $._paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        PausableStorage storage $ = _getPausableStorage();
        $._paused = false;
        emit Unpaused(_msgSender());
    }
}

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

import {IERC20} from '../oz-common/interfaces/IERC20.sol';
import {RescuableBase} from './RescuableBase.sol';
import {IRescuable} from './interfaces/IRescuable.sol';

/**
 * @title Rescuable
 * @author BGD Labs
 * @notice abstract contract with the methods to rescue tokens (ERC20 and native)  from a contract
 */
abstract contract Rescuable is RescuableBase, IRescuable {
  /// @notice modifier that checks that caller is allowed address
  modifier onlyRescueGuardian() {
    if (msg.sender != whoCanRescue()) {
      revert OnlyRescueGuardian();
    }
    _;
  }

  /// @inheritdoc IRescuable
  function emergencyTokenTransfer(
    address erc20Token,
    address to,
    uint256 amount
  ) external virtual onlyRescueGuardian {
    _emergencyTokenTransfer(erc20Token, to, amount);
  }

  /// @inheritdoc IRescuable
  function emergencyEtherTransfer(address to, uint256 amount) external virtual onlyRescueGuardian {
    _emergencyEtherTransfer(to, amount);
  }

  function whoCanRescue() public view virtual returns (address);
}

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

import {IERC20} from '../oz-common/interfaces/IERC20.sol';
import {SafeERC20} from '../oz-common/SafeERC20.sol';
import {IRescuableBase} from './interfaces/IRescuableBase.sol';

abstract contract RescuableBase is IRescuableBase {
  using SafeERC20 for IERC20;

  /// @inheritdoc IRescuableBase
  function maxRescue(address erc20Token) public view virtual returns (uint256);

  function _emergencyTokenTransfer(address erc20Token, address to, uint256 amount) internal {
    uint256 max = maxRescue(erc20Token);
    amount = max > amount ? amount : max;
    IERC20(erc20Token).safeTransfer(to, amount);

    emit ERC20Rescued(msg.sender, erc20Token, to, amount);
  }

  function _emergencyEtherTransfer(address to, uint256 amount) internal {
    (bool success, ) = to.call{value: amount}(new bytes(0));
    if (!success) {
      revert EthTransferFailed();
    }

    emit NativeTokensRescued(msg.sender, to, amount);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
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);
}

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

import {ERC4626Upgradeable, Math, IERC4626} from 'openzeppelin-contracts-upgradeable/contracts/token/ERC20/extensions/ERC4626Upgradeable.sol';
import {SafeERC20, IERC20} from 'openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol';
import {IERC20Permit} from 'openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Permit.sol';

import {IPool, IPoolAddressesProvider} from '../../interfaces/IPool.sol';
import {IAaveOracle} from '../../interfaces/IAaveOracle.sol';
import {DataTypes, ReserveConfiguration} from '../../protocol/libraries/configuration/ReserveConfiguration.sol';

import {IAToken} from './interfaces/IAToken.sol';
import {IERC4626StataToken} from './interfaces/IERC4626StataToken.sol';

/**
 * @title ERC4626StataTokenUpgradeable
 * @notice Wrapper smart contract that allows to deposit tokens on the Aave protocol and receive
 * a token which balance doesn't increase automatically, but uses an ever-increasing exchange rate.
 * @dev ERC20 extension, so ERC20 initialization should be done by the children contract/s
 * @author BGD labs
 */
abstract contract ERC4626StataTokenUpgradeable is ERC4626Upgradeable, IERC4626StataToken {
  using Math for uint256;

  /// @custom:storage-location erc7201:aave-dao.storage.ERC4626StataToken
  struct ERC4626StataTokenStorage {
    IERC20 _aToken;
  }

  // keccak256(abi.encode(uint256(keccak256("aave-dao.storage.ERC4626StataToken")) - 1)) & ~bytes32(uint256(0xff))
  bytes32 private constant ERC4626StataTokenStorageLocation =
    0x55029d3f54709e547ed74b2fc842d93107ab1490ab7555dd9dd0bf6451101900;

  function _getERC4626StataTokenStorage()
    private
    pure
    returns (ERC4626StataTokenStorage storage $)
  {
    assembly {
      $.slot := ERC4626StataTokenStorageLocation
    }
  }

  uint256 public constant RAY = 1e27;

  IPool public immutable POOL;
  IPoolAddressesProvider public immutable POOL_ADDRESSES_PROVIDER;

  constructor(IPool pool) {
    POOL = pool;
    POOL_ADDRESSES_PROVIDER = pool.ADDRESSES_PROVIDER();
  }

  function __ERC4626StataToken_init(address newAToken) internal onlyInitializing {
    IERC20 aTokenUnderlying = __ERC4626StataToken_init_unchained(newAToken);
    __ERC4626_init_unchained(aTokenUnderlying);
  }

  function __ERC4626StataToken_init_unchained(
    address newAToken
  ) internal onlyInitializing returns (IERC20) {
    // sanity check, to be sure that we support that version of the aToken
    address poolOfAToken = IAToken(newAToken).POOL();
    if (poolOfAToken != address(POOL)) revert PoolAddressMismatch(poolOfAToken);

    IERC20 aTokenUnderlying = IERC20(IAToken(newAToken).UNDERLYING_ASSET_ADDRESS());

    ERC4626StataTokenStorage storage $ = _getERC4626StataTokenStorage();
    $._aToken = IERC20(newAToken);

    SafeERC20.forceApprove(aTokenUnderlying, address(POOL), type(uint256).max);

    return aTokenUnderlying;
  }

  ///@inheritdoc IERC4626StataToken
  function depositATokens(uint256 assets, address receiver) external returns (uint256) {
    // because aToken is rebasable, we allow user to specify more then he has to compensate growth during the tx mining
    uint256 actualUserBalance = IERC20(aToken()).balanceOf(_msgSender());
    if (assets > actualUserBalance) {
      assets = actualUserBalance;
    }

    uint256 shares = previewDeposit(assets);
    _deposit(_msgSender(), receiver, assets, shares, false);

    return shares;
  }

  ///@inheritdoc IERC4626StataToken
  function depositWithPermit(
    uint256 assets,
    address receiver,
    uint256 deadline,
    SignatureParams memory sig,
    bool depositToAave
  ) external returns (uint256) {
    address assetToDeposit = depositToAave ? asset() : aToken();

    try
      IERC20Permit(assetToDeposit).permit(
        _msgSender(),
        address(this),
        assets,
        deadline,
        sig.v,
        sig.r,
        sig.s
      )
    {} catch {}

    // because aToken is rebasable, we allow user to specify more then he has to compensate growth during the tx mining
    // to make it consistent, we keep the same behaviour for the normal underlying too
    uint256 actualUserBalance = IERC20(assetToDeposit).balanceOf(_msgSender());
    if (assets > actualUserBalance) {
      assets = actualUserBalance;
    }

    uint256 shares = previewDeposit(assets);
    _deposit(_msgSender(), receiver, assets, shares, depositToAave);
    return shares;
  }

  ///@inheritdoc IERC4626StataToken
  function redeemATokens(
    uint256 shares,
    address receiver,
    address owner
  ) external returns (uint256) {
    uint256 assets = previewRedeem(shares);
    _withdraw(_msgSender(), receiver, owner, assets, shares, false);

    return assets;
  }

  ///@inheritdoc IERC4626StataToken
  function aToken() public view returns (address) {
    ERC4626StataTokenStorage storage $ = _getERC4626StataTokenStorage();
    return address($._aToken);
  }

  ///@inheritdoc IERC4626
  function maxMint(address) public view override returns (uint256) {
    uint256 assets = maxDeposit(address(0));
    if (assets == type(uint256).max) return type(uint256).max;
    return convertToShares(assets);
  }

  ///@inheritdoc IERC4626
  function maxWithdraw(address owner) public view override returns (uint256) {
    return convertToAssets(maxRedeem(owner));
  }

  ///@inheritdoc IERC4626
  function totalAssets() public view override returns (uint256) {
    return _convertToAssets(totalSupply(), Math.Rounding.Floor);
  }

  ///@inheritdoc IERC4626
  function maxRedeem(address owner) public view override returns (uint256) {
    DataTypes.ReserveConfigurationMap memory reserveConfiguration = POOL.getConfiguration(asset());

    // if paused or inactive users cannot withdraw underlying
    if (
      !ReserveConfiguration.getActive(reserveConfiguration) ||
      ReserveConfiguration.getPaused(reserveConfiguration)
    ) {
      return 0;
    }

    // otherwise users can withdraw up to the available amount
    uint128 virtualUnderlyingBalance = POOL.getVirtualUnderlyingBalance(asset());
    uint256 underlyingTokenBalanceInShares = convertToShares(virtualUnderlyingBalance);
    uint256 cachedUserBalance = balanceOf(owner);
    return
      underlyingTokenBalanceInShares >= cachedUserBalance
        ? cachedUserBalance
        : underlyingTokenBalanceInShares;
  }

  ///@inheritdoc IERC4626
  function maxDeposit(address) public view override returns (uint256) {
    DataTypes.ReserveDataLegacy memory reserveData = POOL.getReserveData(asset());

    // if inactive, paused or frozen users cannot deposit underlying
    if (
      !ReserveConfiguration.getActive(reserveData.configuration) ||
      ReserveConfiguration.getPaused(reserveData.configuration) ||
      ReserveConfiguration.getFrozen(reserveData.configuration)
    ) {
      return 0;
    }

    uint256 supplyCap = ReserveConfiguration.getSupplyCap(reserveData.configuration) *
      (10 ** ReserveConfiguration.getDecimals(reserveData.configuration));
    // if no supply cap deposit is unlimited
    if (supplyCap == 0) return type(uint256).max;

    // return remaining supply cap margin
    uint256 currentSupply = (IAToken(reserveData.aTokenAddress).scaledTotalSupply() +
      reserveData.accruedToTreasury).mulDiv(_rate(), RAY, Math.Rounding.Ceil);
    return currentSupply >= supplyCap ? 0 : supplyCap - currentSupply;
  }

  ///@inheritdoc IERC4626StataToken
  function latestAnswer() external view returns (int256) {
    uint256 aTokenUnderlyingAssetPrice = IAaveOracle(POOL_ADDRESSES_PROVIDER.getPriceOracle())
      .getAssetPrice(asset());
    // @notice aTokenUnderlyingAssetPrice * rate / RAY
    return int256(aTokenUnderlyingAssetPrice.mulDiv(_rate(), RAY, Math.Rounding.Floor));
  }

  function _deposit(
    address caller,
    address receiver,
    uint256 assets,
    uint256 shares,
    bool depositToAave
  ) internal virtual {
    if (shares == 0) {
      revert StaticATokenInvalidZeroShares();
    }
    // If _asset is ERC777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the
    // `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer,
    // calls the vault, which is assumed not malicious.
    //
    // Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the
    // assets are transferred and before the shares are minted, which is a valid state.
    // slither-disable-next-line reentrancy-no-eth

    if (depositToAave) {
      address cachedAsset = asset();
      SafeERC20.safeTransferFrom(IERC20(cachedAsset), caller, address(this), assets);
      POOL.deposit(cachedAsset, assets, address(this), 0);
    } else {
      ERC4626StataTokenStorage storage $ = _getERC4626StataTokenStorage();
      SafeERC20.safeTransferFrom($._aToken, caller, address(this), assets);
    }
    _mint(receiver, shares);

    emit Deposit(caller, receiver, assets, shares);
  }

  function _deposit(
    address caller,
    address receiver,
    uint256 assets,
    uint256 shares
  ) internal virtual override {
    _deposit(caller, receiver, assets, shares, true);
  }

  function _withdraw(
    address caller,
    address receiver,
    address owner,
    uint256 assets,
    uint256 shares,
    bool withdrawFromAave
  ) internal virtual {
    if (caller != owner) {
      _spendAllowance(owner, caller, shares);
    }

    // If _asset is ERC777, `transfer` can trigger a reentrancy AFTER the transfer happens through the
    // `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer,
    // calls the vault, which is assumed not malicious.
    //
    // Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the
    // shares are burned and after the assets are transferred, which is a valid state.
    _burn(owner, shares);
    if (withdrawFromAave) {
      POOL.withdraw(asset(), assets, receiver);
    } else {
      ERC4626StataTokenStorage storage $ = _getERC4626StataTokenStorage();
      SafeERC20.safeTransfer($._aToken, receiver, assets);
    }

    emit Withdraw(caller, receiver, owner, assets, shares);
  }

  function _withdraw(
    address caller,
    address receiver,
    address owner,
    uint256 assets,
    uint256 shares
  ) internal virtual override {
    _withdraw(caller, receiver, owner, assets, shares, true);
  }

  function _convertToShares(
    uint256 assets,
    Math.Rounding rounding
  ) internal view virtual override returns (uint256) {
    // * @notice assets * RAY / exchangeRate
    return assets.mulDiv(RAY, _rate(), rounding);
  }

  function _convertToAssets(
    uint256 shares,
    Math.Rounding rounding
  ) internal view virtual override returns (uint256) {
    // * @notice share * exchangeRate / RAY
    return shares.mulDiv(_rate(), RAY, rounding);
  }

  function _rate() internal view returns (uint256) {
    return POOL.getReserveNormalizedIncome(asset());
  }
}

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

import {ERC20Upgradeable} from 'openzeppelin-contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol';
import {IERC20} from 'openzeppelin-contracts/contracts/interfaces/IERC20.sol';
import {SafeERC20} from 'openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol';
import {SafeCast} from 'solidity-utils/contracts/oz-common/SafeCast.sol';

import {IRewardsController} from '../../rewards/interfaces/IRewardsController.sol';
import {IERC20AaveLM} from './interfaces/IERC20AaveLM.sol';

/**
 * @title ERC20AaveLMUpgradeable.sol
 * @notice Wrapper smart contract that supports tracking and claiming liquidity mining rewards from the Aave system
 * @dev ERC20 extension, so ERC20 initialization should be done by the children contract/s
 * @author BGD labs
 */
abstract contract ERC20AaveLMUpgradeable is ERC20Upgradeable, IERC20AaveLM {
  using SafeCast for uint256;

  /// @custom:storage-location erc7201:aave-dao.storage.ERC20AaveLM
  struct ERC20AaveLMStorage {
    address _referenceAsset; // a/v token to track rewards on INCENTIVES_CONTROLLER
    address[] _rewardTokens;
    mapping(address reward => RewardIndexCache cache) _startIndex;
    mapping(address user => mapping(address reward => UserRewardsData cache)) _userRewardsData;
  }

  // keccak256(abi.encode(uint256(keccak256("aave-dao.storage.ERC20AaveLM")) - 1)) & ~bytes32(uint256(0xff))
  bytes32 private constant ERC20AaveLMStorageLocation =
    0x4fad66563f105be0bff96185c9058c4934b504d3ba15ca31e86294f0b01fd200;

  function _getERC20AaveLMStorage() private pure returns (ERC20AaveLMStorage storage $) {
    assembly {
      $.slot := ERC20AaveLMStorageLocation
    }
  }

  IRewardsController public immutable INCENTIVES_CONTROLLER;

  constructor(IRewardsController rewardsController) {
    if (address(rewardsController) == address(0)) {
      revert ZeroIncentivesControllerIsForbidden();
    }
    INCENTIVES_CONTROLLER = rewardsController;
  }

  function __ERC20AaveLM_init(address referenceAsset_) internal onlyInitializing {
    __ERC20AaveLM_init_unchained(referenceAsset_);
  }

  function __ERC20AaveLM_init_unchained(address referenceAsset_) internal onlyInitializing {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    $._referenceAsset = referenceAsset_;

    if (INCENTIVES_CONTROLLER != IRewardsController(address(0))) {
      refreshRewardTokens();
    }
  }

  ///@inheritdoc IERC20AaveLM
  function claimRewardsOnBehalf(
    address onBehalfOf,
    address receiver,
    address[] memory rewards
  ) external {
    address msgSender = _msgSender();
    if (msgSender != onBehalfOf && msgSender != INCENTIVES_CONTROLLER.getClaimer(onBehalfOf)) {
      revert InvalidClaimer(msgSender);
    }

    _claimRewardsOnBehalf(onBehalfOf, receiver, rewards);
  }

  ///@inheritdoc IERC20AaveLM
  function claimRewards(address receiver, address[] memory rewards) external {
    _claimRewardsOnBehalf(_msgSender(), receiver, rewards);
  }

  ///@inheritdoc IERC20AaveLM
  function claimRewardsToSelf(address[] memory rewards) external {
    _claimRewardsOnBehalf(_msgSender(), _msgSender(), rewards);
  }

  ///@inheritdoc IERC20AaveLM
  function refreshRewardTokens() public override {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    address[] memory rewards = INCENTIVES_CONTROLLER.getRewardsByAsset($._referenceAsset);
    for (uint256 i = 0; i < rewards.length; i++) {
      _registerRewardToken(rewards[i]);
    }
  }

  ///@inheritdoc IERC20AaveLM
  function collectAndUpdateRewards(address reward) public returns (uint256) {
    if (reward == address(0)) {
      return 0;
    }

    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    address[] memory assets = new address[](1);
    assets[0] = address($._referenceAsset);

    return INCENTIVES_CONTROLLER.claimRewards(assets, type(uint256).max, address(this), reward);
  }

  ///@inheritdoc IERC20AaveLM
  function isRegisteredRewardToken(address reward) public view override returns (bool) {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    return $._startIndex[reward].isRegistered;
  }

  ///@inheritdoc IERC20AaveLM
  function getCurrentRewardsIndex(address reward) public view returns (uint256) {
    if (address(reward) == address(0)) {
      return 0;
    }
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    (, uint256 nextIndex) = INCENTIVES_CONTROLLER.getAssetIndex($._referenceAsset, reward);
    return nextIndex;
  }

  ///@inheritdoc IERC20AaveLM
  function getTotalClaimableRewards(address reward) external view returns (uint256) {
    if (reward == address(0)) {
      return 0;
    }

    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    address[] memory assets = new address[](1);
    assets[0] = $._referenceAsset;
    uint256 freshRewards = INCENTIVES_CONTROLLER.getUserRewards(assets, address(this), reward);
    return IERC20(reward).balanceOf(address(this)) + freshRewards;
  }

  ///@inheritdoc IERC20AaveLM
  function getClaimableRewards(address user, address reward) external view returns (uint256) {
    return _getClaimableRewards(user, reward, balanceOf(user), getCurrentRewardsIndex(reward));
  }

  ///@inheritdoc IERC20AaveLM
  function getUnclaimedRewards(address user, address reward) external view returns (uint256) {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    return $._userRewardsData[user][reward].unclaimedRewards;
  }

  ///@inheritdoc IERC20AaveLM
  function getReferenceAsset() external view returns (address) {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    return $._referenceAsset;
  }

  ///@inheritdoc IERC20AaveLM
  function rewardTokens() external view returns (address[] memory) {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    return $._rewardTokens;
  }

  /**
   * @notice Updates rewards for senders and receiver in a transfer (not updating rewards for address(0))
   * @param from The address of the sender of tokens
   * @param to The address of the receiver of tokens
   */
  function _update(address from, address to, uint256 amount) internal virtual override {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    for (uint256 i = 0; i < $._rewardTokens.length; i++) {
      address rewardToken = address($._rewardTokens[i]);
      uint256 rewardsIndex = getCurrentRewardsIndex(rewardToken);
      if (from != address(0)) {
        _updateUser(from, rewardsIndex, rewardToken);
      }
      if (to != address(0) && from != to) {
        _updateUser(to, rewardsIndex, rewardToken);
      }
    }
    super._update(from, to, amount);
  }

  /**
   * @notice Adding the pending rewards to the unclaimed for specific user and updating user index
   * @param user The address of the user to update
   * @param currentRewardsIndex The current rewardIndex
   * @param rewardToken The address of the reward token
   */
  function _updateUser(address user, uint256 currentRewardsIndex, address rewardToken) internal {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    uint256 balance = balanceOf(user);
    if (balance > 0) {
      $._userRewardsData[user][rewardToken].unclaimedRewards = _getClaimableRewards(
        user,
        rewardToken,
        balance,
        currentRewardsIndex
      ).toUint128();
    }
    $._userRewardsData[user][rewardToken].rewardsIndexOnLastInteraction = currentRewardsIndex
      .toUint128();
  }

  /**
   * @notice Compute the pending in asset decimals. Pending is the amount to add (not yet unclaimed) rewards in asset decimals.
   * @param balance The balance of the user
   * @param rewardsIndexOnLastInteraction The index which was on the last interaction of the user
   * @param currentRewardsIndex The current rewards index in the system
   * @return The amount of pending rewards in asset decimals
   */
  function _getPendingRewards(
    uint256 balance,
    uint256 rewardsIndexOnLastInteraction,
    uint256 currentRewardsIndex
  ) internal view returns (uint256) {
    if (balance == 0) {
      return 0;
    }
    return (balance * (currentRewardsIndex - rewardsIndexOnLastInteraction)) / 10 ** decimals();
  }

  /**
   * @notice Compute the claimable rewards for a user
   * @param user The address of the user
   * @param reward The address of the reward
   * @param balance The balance of the user in asset decimals
   * @param currentRewardsIndex The current rewards index
   * @return The total rewards that can be claimed by the user (if `fresh` flag true, after updating rewards)
   */
  function _getClaimableRewards(
    address user,
    address reward,
    uint256 balance,
    uint256 currentRewardsIndex
  ) internal view returns (uint256) {
    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    RewardIndexCache memory rewardsIndexCache = $._startIndex[reward];
    if (!rewardsIndexCache.isRegistered) {
      revert RewardNotInitialized(reward);
    }

    UserRewardsData memory currentUserRewardsData = $._userRewardsData[user][reward];
    return
      currentUserRewardsData.unclaimedRewards +
      _getPendingRewards(
        balance,
        currentUserRewardsData.rewardsIndexOnLastInteraction == 0
          ? rewardsIndexCache.lastUpdatedIndex
          : currentUserRewardsData.rewardsIndexOnLastInteraction,
        currentRewardsIndex
      );
  }

  /**
   * @notice Claim rewards on behalf of a user and send them to a receiver
   * @param onBehalfOf The address to claim on behalf of
   * @param rewards The addresses of the rewards
   * @param receiver The address to receive the rewards
   */
  function _claimRewardsOnBehalf(
    address onBehalfOf,
    address receiver,
    address[] memory rewards
  ) internal virtual {
    for (uint256 i = 0; i < rewards.length; i++) {
      if (address(rewards[i]) == address(0)) {
        continue;
      }
      uint256 currentRewardsIndex = getCurrentRewardsIndex(rewards[i]);
      uint256 balance = balanceOf(onBehalfOf);
      uint256 userReward = _getClaimableRewards(
        onBehalfOf,
        rewards[i],
        balance,
        currentRewardsIndex
      );
      uint256 totalRewardTokenBalance = IERC20(rewards[i]).balanceOf(address(this));
      uint256 unclaimedReward = 0;

      if (userReward > totalRewardTokenBalance) {
        totalRewardTokenBalance += collectAndUpdateRewards(address(rewards[i]));
      }

      if (userReward > totalRewardTokenBalance) {
        unclaimedReward = userReward - totalRewardTokenBalance;
        userReward = totalRewardTokenBalance;
      }
      if (userReward > 0) {
        ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
        $._userRewardsData[onBehalfOf][rewards[i]].unclaimedRewards = unclaimedReward.toUint128();
        $
        ._userRewardsData[onBehalfOf][rewards[i]]
          .rewardsIndexOnLastInteraction = currentRewardsIndex.toUint128();
        SafeERC20.safeTransfer(IERC20(rewards[i]), receiver, userReward);
      }
    }
  }

  /**
   * @notice Initializes a new rewardToken
   * @param reward The reward token to be registered
   */
  function _registerRewardToken(address reward) internal {
    if (isRegisteredRewardToken(reward)) return;
    uint256 startIndex = getCurrentRewardsIndex(reward);

    ERC20AaveLMStorage storage $ = _getERC20AaveLMStorage();
    $._rewardTokens.push(reward);
    $._startIndex[reward] = RewardIndexCache(true, startIndex.toUint248());

    emit RewardTokenRegistered(reward, startIndex);
  }
}

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

import {IERC4626StataToken} from './IERC4626StataToken.sol';
import {IERC20AaveLM} from './IERC20AaveLM.sol';
import {IERC4626} from '@openzeppelin/contracts/interfaces/IERC4626.sol';
import {IERC20Permit} from '@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol';

interface IStataTokenV2 is IERC4626, IERC20Permit, IERC4626StataToken, IERC20AaveLM {
  /**
   * @notice Checks if the passed actor is permissioned emergency admin.
   * @param actor The reward to claim
   * @return bool signaling if actor can pause the vault.
   */
  function canPause(address actor) external view returns (bool);

  /**
   * @notice Pauses/unpauses all system's operations
   * @param paused boolean determining if the token should be paused or unpaused
   */
  function setPaused(bool paused) external;
}

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

interface IAToken {
  function POOL() external view returns (address);

  function getIncentivesController() external view returns (address);

  function UNDERLYING_ASSET_ADDRESS() external view returns (address);

  function RESERVE_TREASURY_ADDRESS() external view returns (address);

  /**
   * @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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
    /// @custom:storage-location erc7201:openzeppelin.storage.ERC20
    struct ERC20Storage {
        mapping(address account => uint256) _balances;

        mapping(address account => mapping(address spender => uint256)) _allowances;

        uint256 _totalSupply;

        string _name;
        string _symbol;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;

    function _getERC20Storage() private pure returns (ERC20Storage storage $) {
        assembly {
            $.slot := ERC20StorageLocation
        }
    }

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        ERC20Storage storage $ = _getERC20Storage();
        $._name = name_;
        $._symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        ERC20Storage storage $ = _getERC20Storage();
        return $._allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            $._totalSupply += value;
        } else {
            uint256 fromBalance = $._balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                $._balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                $._totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                $._balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        ERC20Storage storage $ = _getERC20Storage();
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        $._allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.20;

import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
 * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
 * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
 * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 */
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
    bytes32 private constant TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @custom:storage-location erc7201:openzeppelin.storage.EIP712
    struct EIP712Storage {
        /// @custom:oz-renamed-from _HASHED_NAME
        bytes32 _hashedName;
        /// @custom:oz-renamed-from _HASHED_VERSION
        bytes32 _hashedVersion;

        string _name;
        string _version;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.EIP712")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;

    function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
        assembly {
            $.slot := EIP712StorageLocation
        }
    }

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        EIP712Storage storage $ = _getEIP712Storage();
        $._name = name;
        $._version = version;

        // Reset prior values in storage if upgrading
        $._hashedName = 0;
        $._hashedVersion = 0;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator();
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        EIP712Storage storage $ = _getEIP712Storage();
        // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
        // and the EIP712 domain is not reliable, as it will be missing name and version.
        require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");

        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Name() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._name;
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Version() internal view virtual returns (string memory) {
        EIP712Storage storage $ = _getEIP712Storage();
        return $._version;
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
     */
    function _EIP712NameHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory name = _EIP712Name();
        if (bytes(name).length > 0) {
            return keccak256(bytes(name));
        } else {
            // If the name is empty, the contract may have been upgraded without initializing the new storage.
            // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
            bytes32 hashedName = $._hashedName;
            if (hashedName != 0) {
                return hashedName;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
     */
    function _EIP712VersionHash() internal view returns (bytes32) {
        EIP712Storage storage $ = _getEIP712Storage();
        string memory version = _EIP712Version();
        if (bytes(version).length > 0) {
            return keccak256(bytes(version));
        } else {
            // If the version is empty, the contract may have been upgraded without initializing the new storage.
            // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
            bytes32 hashedVersion = $._hashedVersion;
            if (hashedVersion != 0) {
                return hashedVersion;
            } else {
                return keccak256("");
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Provides tracking nonces for addresses. Nonces will only increment.
 */
abstract contract NoncesUpgradeable is Initializable {
    /**
     * @dev The nonce used for an `account` is not the expected current nonce.
     */
    error InvalidAccountNonce(address account, uint256 currentNonce);

    /// @custom:storage-location erc7201:openzeppelin.storage.Nonces
    struct NoncesStorage {
        mapping(address account => uint256) _nonces;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Nonces")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant NoncesStorageLocation = 0x5ab42ced628888259c08ac98db1eb0cf702fc1501344311d8b100cd1bfe4bb00;

    function _getNoncesStorage() private pure returns (NoncesStorage storage $) {
        assembly {
            $.slot := NoncesStorageLocation
        }
    }

    function __Nonces_init() internal onlyInitializing {
    }

    function __Nonces_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns the next unused nonce for an address.
     */
    function nonces(address owner) public view virtual returns (uint256) {
        NoncesStorage storage $ = _getNoncesStorage();
        return $._nonces[owner];
    }

    /**
     * @dev Consumes a nonce.
     *
     * Returns the current value and increments nonce.
     */
    function _useNonce(address owner) internal virtual returns (uint256) {
        NoncesStorage storage $ = _getNoncesStorage();
        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
        // decremented or reset. This guarantees that the nonce never overflows.
        unchecked {
            // It is important to do x++ and not ++x here.
            return $._nonces[owner]++;
        }
    }

    /**
     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
     */
    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
        uint256 current = _useNonce(owner);
        if (nonce != current) {
            revert InvalidAccountNonce(owner, current);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.20;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Storage of the initializable contract.
     *
     * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
     * when using with upgradeable contracts.
     *
     * @custom:storage-location erc7201:openzeppelin.storage.Initializable
     */
    struct InitializableStorage {
        /**
         * @dev Indicates that the contract has been initialized.
         */
        uint64 _initialized;
        /**
         * @dev Indicates that the contract is in the process of being initialized.
         */
        bool _initializing;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;

    /**
     * @dev The contract is already initialized.
     */
    error InvalidInitialization();

    /**
     * @dev The contract is not initializing.
     */
    error NotInitializing();

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint64 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
     * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
     * production.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        // Cache values to avoid duplicated sloads
        bool isTopLevelCall = !$._initializing;
        uint64 initialized = $._initialized;

        // Allowed calls:
        // - initialSetup: the contract is not in the initializing state and no previous version was
        //                 initialized
        // - construction: the contract is initialized at version 1 (no reininitialization) and the
        //                 current contract is just being deployed
        bool initialSetup = initialized == 0 && isTopLevelCall;
        bool construction = initialized == 1 && address(this).code.length == 0;

        if (!initialSetup && !construction) {
            revert InvalidInitialization();
        }
        $._initialized = 1;
        if (isTopLevelCall) {
            $._initializing = true;
        }
        _;
        if (isTopLevelCall) {
            $._initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint64 version) {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing || $._initialized >= version) {
            revert InvalidInitialization();
        }
        $._initialized = version;
        $._initializing = true;
        _;
        $._initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        _checkInitializing();
        _;
    }

    /**
     * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
     */
    function _checkInitializing() internal view virtual {
        if (!_isInitializing()) {
            revert NotInitializing();
        }
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        // solhint-disable-next-line var-name-mixedcase
        InitializableStorage storage $ = _getInitializableStorage();

        if ($._initializing) {
            revert InvalidInitialization();
        }
        if ($._initialized != type(uint64).max) {
            $._initialized = type(uint64).max;
            emit Initialized(type(uint64).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint64) {
        return _getInitializableStorage()._initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _getInitializableStorage()._initializing;
    }

    /**
     * @dev Returns a pointer to the storage namespace.
     */
    // solhint-disable-next-line var-name-mixedcase
    function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
        assembly {
            $.slot := INITIALIZABLE_STORAGE
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @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 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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
// From commit https://github.com/OpenZeppelin/openzeppelin-contracts/commit/a035b235b4f2c9af4ba88edc4447f02e37f8d124

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
  /**
   * @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);

  /**
   * @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 `to`.
   *
   * Returns a boolean value indicating whether the operation succeeded.
   *
   * Emits a {Transfer} event.
   */
  function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

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

import {IRescuableBase} from './IRescuableBase.sol';

/**
 * @title IRescuable
 * @author BGD Labs
 * @notice interface containing the objects, events and methods definitions of the Rescuable contract
 */
interface IRescuable is IRescuableBase {
  error OnlyRescueGuardian();

  /**
   * @notice method called to rescue tokens sent erroneously to the contract. Only callable by owner
   * @param erc20Token address of the token to rescue
   * @param to address to send the tokens
   * @param amount of tokens to rescue
   */
  function emergencyTokenTransfer(address erc20Token, address to, uint256 amount) external;

  /**
   * @notice method called to rescue ether sent erroneously to the contract. Only callable by owner
   * @param to address to send the eth
   * @param amount of eth to rescue
   */
  function emergencyEtherTransfer(address to, uint256 amount) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol)
// Modified From commit https://github.com/OpenZeppelin/openzeppelin-contracts/commit/00cbf5a236564c3b7aacdad1f378cae22d890ca6

pragma solidity ^0.8.0;

import {IERC20} from "./interfaces/IERC20.sol";
import {IERC20Permit} from "./interfaces/IERC20Permit.sol";
import {Address} from "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
  using Address for address;

  /**
   * @dev An operation with an ERC20 token failed.
     */
  error SafeERC20FailedOperation(address token);

  /**
   * @dev Indicates a failed `decreaseAllowance` request.
     */
  error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

  /**
   * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
  function safeTransfer(IERC20 token, address to, uint256 value) internal {
    _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
  }

  /**
   * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
  function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
  }

  /**
   * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
  function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    uint256 oldAllowance = token.allowance(address(this), spender);
    forceApprove(token, spender, oldAllowance + value);
  }

  /**
   * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
  function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
    unchecked {
      uint256 currentAllowance = token.allowance(address(this), spender);
      if (currentAllowance < requestedDecrease) {
        revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
      }
      forceApprove(token, spender, currentAllowance - requestedDecrease);
    }
  }

  /**
   * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
  function forceApprove(IERC20 token, address spender, uint256 value) internal {
    bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

    if (!_callOptionalReturnBool(token, approvalCall)) {
      _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
      _callOptionalReturn(token, approvalCall);
    }
  }

  /**
   * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
  function safePermit(
    IERC20Permit token,
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) internal {
    uint256 nonceBefore = token.nonces(owner);
    token.permit(owner, spender, value, deadline, v, r, s);
    uint256 nonceAfter = token.nonces(owner);
    if (nonceAfter != nonceBefore + 1) {
      revert SafeERC20FailedOperation(address(token));
    }
  }

  /**
   * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
  function _callOptionalReturn(IERC20 token, bytes memory data) private {
    // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
    // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
    // the target address contains contract code and also asserts for success in the low-level call.

    bytes memory returndata = address(token).functionCall(data);
    if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
      revert SafeERC20FailedOperation(address(token));
    }
  }

  /**
   * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
  function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
    // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
    // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
    // and not revert is the subcall reverts.

    (bool success, bytes memory returndata) = address(token).call(data);
    return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
  }
}

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

/**
 * @title IRescuableBase
 * @author BGD Labs
 * @notice interface containing the objects, events and methods definitions of the RescuableBase contract
 */
interface IRescuableBase {
  error EthTransferFailed();
  /**
   * @notice emitted when erc20 tokens get rescued
   * @param caller address that triggers the rescue
   * @param token address of the rescued token
   * @param to address that will receive the rescued tokens
   * @param amount quantity of tokens rescued
   */
  event ERC20Rescued(
    address indexed caller,
    address indexed token,
    address indexed to,
    uint256 amount
  );

  /**
   * @notice emitted when native tokens get rescued
   * @param caller address that triggers the rescue
   * @param to address that will receive the rescued tokens
   * @param amount quantity of tokens rescued
   */
  event NativeTokensRescued(address indexed caller, address indexed to, uint256 amount);

  /**
   * @notice method that defined the maximum amount rescuable for any given asset.
   * @dev there's currently no way to limit the rescuable "native asset", as we assume erc20s as intended underlying.
   * @return the maximum amount of
   */
  function maxRescue(address erc20Token) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
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
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC4626.sol)

pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ERC20Upgradeable} from "../ERC20Upgradeable.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {Initializable} from "../../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the ERC4626 "Tokenized Vault Standard" as defined in
 * https://eips.ethereum.org/EIPS/eip-4626[EIP-4626].
 *
 * This extension allows the minting and burning of "shares" (represented using the ERC20 inheritance) in exchange for
 * underlying "assets" through standardized {deposit}, {mint}, {redeem} and {burn} workflows. This contract extends
 * the ERC20 standard. Any additional extensions included along it would affect the "shares" token represented by this
 * contract and not the "assets" token which is an independent contract.
 *
 * [CAUTION]
 * ====
 * In empty (or nearly empty) ERC-4626 vaults, deposits are at high risk of being stolen through frontrunning
 * with a "donation" to the vault that inflates the price of a share. This is variously known as a donation or inflation
 * attack and is essentially a problem of slippage. Vault deployers can protect against this attack by making an initial
 * deposit of a non-trivial amount of the asset, such that price manipulation becomes infeasible. Withdrawals may
 * similarly be affected by slippage. Users can protect against this attack as well as unexpected slippage in general by
 * verifying the amount received is as expected, using a wrapper that performs these checks such as
 * https://github.com/fei-protocol/ERC4626#erc4626router-and-base[ERC4626Router].
 *
 * Since v4.9, this implementation uses virtual assets and shares to mitigate that risk. The `_decimalsOffset()`
 * corresponds to an offset in the decimal representation between the underlying asset's decimals and the vault
 * decimals. This offset also determines the rate of virtual shares to virtual assets in the vault, which itself
 * determines the initial exchange rate. While not fully preventing the attack, analysis shows that the default offset
 * (0) makes it non-profitable, as a result of the value being captured by the virtual shares (out of the attacker's
 * donation) matching the attacker's expected gains. With a larger offset, the attack becomes orders of magnitude more
 * expensive than it is profitable. More details about the underlying math can be found
 * xref:erc4626.adoc#inflation-attack[here].
 *
 * The drawback of this approach is that the virtual shares do capture (a very small) part of the value being accrued
 * to the vault. Also, if the vault experiences losses, the users try to exit the vault, the virtual shares and assets
 * will cause the first user to exit to experience reduced losses in detriment to the last users that will experience
 * bigger losses. Developers willing to revert back to the pre-v4.9 behavior just need to override the
 * `_convertToShares` and `_convertToAssets` functions.
 *
 * To learn more, check out our xref:ROOT:erc4626.adoc[ERC-4626 guide].
 * ====
 */
abstract contract ERC4626Upgradeable is Initializable, ERC20Upgradeable, IERC4626 {
    using Math for uint256;

    /// @custom:storage-location erc7201:openzeppelin.storage.ERC4626
    struct ERC4626Storage {
        IERC20 _asset;
        uint8 _underlyingDecimals;
    }

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC4626")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant ERC4626StorageLocation = 0x0773e532dfede91f04b12a73d3d2acd361424f41f76b4fb79f090161e36b4e00;

    function _getERC4626Storage() private pure returns (ERC4626Storage storage $) {
        assembly {
            $.slot := ERC4626StorageLocation
        }
    }

    /**
     * @dev Attempted to deposit more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxDeposit(address receiver, uint256 assets, uint256 max);

    /**
     * @dev Attempted to mint more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxMint(address receiver, uint256 shares, uint256 max);

    /**
     * @dev Attempted to withdraw more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max);

    /**
     * @dev Attempted to redeem more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max);

    /**
     * @dev Set the underlying asset contract. This must be an ERC20-compatible contract (ERC20 or ERC777).
     */
    function __ERC4626_init(IERC20 asset_) internal onlyInitializing {
        __ERC4626_init_unchained(asset_);
    }

    function __ERC4626_init_unchained(IERC20 asset_) internal onlyInitializing {
        ERC4626Storage storage $ = _getERC4626Storage();
        (bool success, uint8 assetDecimals) = _tryGetAssetDecimals(asset_);
        $._underlyingDecimals = success ? assetDecimals : 18;
        $._asset = asset_;
    }

    /**
     * @dev Attempts to fetch the asset decimals. A return value of false indicates that the attempt failed in some way.
     */
    function _tryGetAssetDecimals(IERC20 asset_) private view returns (bool, uint8) {
        (bool success, bytes memory encodedDecimals) = address(asset_).staticcall(
            abi.encodeCall(IERC20Metadata.decimals, ())
        );
        if (success && encodedDecimals.length >= 32) {
            uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
            if (returnedDecimals <= type(uint8).max) {
                return (true, uint8(returnedDecimals));
            }
        }
        return (false, 0);
    }

    /**
     * @dev Decimals are computed by adding the decimal offset on top of the underlying asset's decimals. This
     * "original" value is cached during construction of the vault contract. If this read operation fails (e.g., the
     * asset has not been created yet), a default of 18 is used to represent the underlying asset's decimals.
     *
     * See {IERC20Metadata-decimals}.
     */
    function decimals() public view virtual override(IERC20Metadata, ERC20Upgradeable) returns (uint8) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return $._underlyingDecimals + _decimalsOffset();
    }

    /** @dev See {IERC4626-asset}. */
    function asset() public view virtual returns (address) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return address($._asset);
    }

    /** @dev See {IERC4626-totalAssets}. */
    function totalAssets() public view virtual returns (uint256) {
        ERC4626Storage storage $ = _getERC4626Storage();
        return $._asset.balanceOf(address(this));
    }

    /** @dev See {IERC4626-convertToShares}. */
    function convertToShares(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-convertToAssets}. */
    function convertToAssets(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxDeposit}. */
    function maxDeposit(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxMint}. */
    function maxMint(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxWithdraw}. */
    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return _convertToAssets(balanceOf(owner), Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxRedeem}. */
    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf(owner);
    }

    /** @dev See {IERC4626-previewDeposit}. */
    function previewDeposit(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-previewMint}. */
    function previewMint(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewWithdraw}. */
    function previewWithdraw(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewRedeem}. */
    function previewRedeem(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-deposit}. */
    function deposit(uint256 assets, address receiver) public virtual returns (uint256) {
        uint256 maxAssets = maxDeposit(receiver);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxDeposit(receiver, assets, maxAssets);
        }

        uint256 shares = previewDeposit(assets);
        _deposit(_msgSender(), receiver, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-mint}.
     *
     * As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
     * In this case, the shares will be minted without requiring any assets to be deposited.
     */
    function mint(uint256 shares, address receiver) public virtual returns (uint256) {
        uint256 maxShares = maxMint(receiver);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxMint(receiver, shares, maxShares);
        }

        uint256 assets = previewMint(shares);
        _deposit(_msgSender(), receiver, assets, shares);

        return assets;
    }

    /** @dev See {IERC4626-withdraw}. */
    function withdraw(uint256 assets, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxAssets = maxWithdraw(owner);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxWithdraw(owner, assets, maxAssets);
        }

        uint256 shares = previewWithdraw(assets);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-redeem}. */
    function redeem(uint256 shares, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxShares = maxRedeem(owner);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);
        }

        uint256 assets = previewRedeem(shares);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return assets;
    }

    /**
     * @dev Internal conversion function (from assets to shares) with support for rounding direction.
     */
    function _convertToShares(uint256 assets, Math.Rounding rounding) internal view virtual returns (uint256) {
        return assets.mulDiv(totalSupply() + 10 ** _decimalsOffset(), totalAssets() + 1, rounding);
    }

    /**
     * @dev Internal conversion function (from shares to assets) with support for rounding direction.
     */
    function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual returns (uint256) {
        return shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** _decimalsOffset(), rounding);
    }

    /**
     * @dev Deposit/mint common workflow.
     */
    function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual {
        ERC4626Storage storage $ = _getERC4626Storage();
        // If _asset is ERC777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the
        // `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the
        // assets are transferred and before the shares are minted, which is a valid state.
        // slither-disable-next-line reentrancy-no-eth
        SafeERC20.safeTransferFrom($._asset, caller, address(this), assets);
        _mint(receiver, shares);

        emit Deposit(caller, receiver, assets, shares);
    }

    /**
     * @dev Withdraw/redeem common workflow.
     */
    function _withdraw(
        address caller,
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares
    ) internal virtual {
        ERC4626Storage storage $ = _getERC4626Storage();
        if (caller != owner) {
            _spendAllowance(owner, caller, shares);
        }

        // If _asset is ERC777, `transfer` can trigger a reentrancy AFTER the transfer happens through the
        // `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the
        // shares are burned and after the assets are transferred, which is a valid state.
        _burn(owner, shares);
        SafeERC20.safeTransfer($._asset, receiver, assets);

        emit Withdraw(caller, receiver, owner, assets, shares);
    }

    function _decimalsOffset() internal view virtual returns (uint8) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// SPDX-License-Identifier: MIT
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: 2 for Variable, 1 is deprecated (changed on v3.2.0)
   * @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 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 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 (Deprecated on v3.2.0), 2 for Variable
   * @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 @note deprecated on v3.2.0
   * @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 VariableDebtToken
   * - E.g. User borrows 100 USDC passing as `onBehalfOf` his own address, receiving the 100 USDC in his wallet
   *   and 100 variable debt tokens
   * @param asset The address of the underlying asset to borrow
   * @param amount The amount to be borrowed
   * @param interestRateMode 2 for Variable, 1 is deprecated on v3.2.0
   * @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 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 2 for Variable, 1 is deprecated on v3.2.0
   * @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 2 for Variable, 1 is deprecated on v3.2.0
   * @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 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 DEPRECATED in v3.2.0
   * @return The final amount repaid
   */
  function repayWithATokens(
    address asset,
    uint256 amount,
    uint256 interestRateMode
  ) external returns (uint256);

  /**
   * @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 -> Deprecated on v3.2.0
   *   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 2 on `modes`
   * @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 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 variableDebtAddress,
    address interestRateStrategyAddress
  ) external;

  /**
   * @notice Drop a reserve
   * @dev Only callable by the PoolConfigurator contract
   * @dev Does not reset eMode flags, which must be considered when reusing the same reserve id for a different reserve.
   * @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 Accumulates interest to all indexes of the reserve
   * @dev Only callable by the PoolConfigurator contract
   * @dev To be used when required by the configurator, for example when updating interest rates strategy data
   * @param asset The address of the underlying asset of the reserve
   */
  function syncIndexesState(address asset) external;

  /**
   * @notice Updates interest rates on the reserve data
   * @dev Only callable by the PoolConfigurator contract
   * @dev To be used when required by the configurator, for example when updating interest rates strategy data
   * @param asset The address of the underlying asset of the reserve
   */
  function syncRatesState(address asset) 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.ReserveDataLegacy memory);

  /**
   * @notice Returns the state and configuration of the reserve, including extra data included with Aave v3.1
   * @dev DEPRECATED use independent getters instead (getReserveData, getLiquidationGracePeriod)
   * @param asset The address of the underlying asset of the reserve
   * @return The state and configuration data of the reserve with virtual accounting
   */
  function getReserveDataExtended(
    address asset
  ) external view returns (DataTypes.ReserveData memory);

  /**
   * @notice Returns the virtual underlying balance of the reserve
   * @param asset The address of the underlying asset of the reserve
   * @return The reserve virtual underlying balance
   */
  function getVirtualUnderlyingBalance(address asset) external view returns (uint128);

  /**
   * @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 number of initialized reserves
   * @dev It includes dropped reserves
   * @return The count
   */
  function getReservesCount() external view returns (uint256);

  /**
   * @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 or alters an existing collateral configuration of an 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.EModeCategoryBaseConfiguration memory config
  ) external;

  /**
   * @notice Replaces the current eMode collateralBitmap.
   * @param id The id of the category
   * @param collateralBitmap The collateralBitmap of the category
   */
  function configureEModeCategoryCollateralBitmap(uint8 id, uint128 collateralBitmap) external;

  /**
   * @notice Replaces the current eMode borrowableBitmap.
   * @param id The id of the category
   * @param borrowableBitmap The borrowableBitmap of the category
   */
  function configureEModeCategoryBorrowableBitmap(uint8 id, uint128 borrowableBitmap) external;

  /**
   * @notice Returns the data of an eMode category
   * @dev DEPRECATED use independent getters instead
   * @param id The id of the category
   * @return The configuration data of the category
   */
  function getEModeCategoryData(
    uint8 id
  ) external view returns (DataTypes.EModeCategoryLegacy memory);

  /**
   * @notice Returns the label of an eMode category
   * @param id The id of the category
   * @return The label of the category
   */
  function getEModeCategoryLabel(uint8 id) external view returns (string memory);

  /**
   * @notice Returns the collateral config of an eMode category
   * @param id The id of the category
   * @return The ltv,lt,lb of the category
   */
  function getEModeCategoryCollateralConfig(
    uint8 id
  ) external view returns (DataTypes.CollateralConfig memory);

  /**
   * @notice Returns the collateralBitmap of an eMode category
   * @param id The id of the category
   * @return The collateralBitmap of the category
   */
  function getEModeCategoryCollateralBitmap(uint8 id) external view returns (uint128);

  /**
   * @notice Returns the borrowableBitmap of an eMode category
   * @param id The id of the category
   * @return The borrowableBitmap of the category
   */
  function getEModeCategoryBorrowableBitmap(uint8 id) external view returns (uint128);

  /**
   * @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 Sets the liquidation grace period of the given asset
   * @dev To enable a liquidation grace period, a timestamp in the future should be set,
   *      To disable a liquidation grace period, any timestamp in the past works, like 0
   * @param asset The address of the underlying asset to set the liquidationGracePeriod
   * @param until Timestamp when the liquidation grace period will end
   **/
  function setLiquidationGracePeriod(address asset, uint40 until) external;

  /**
   * @notice Returns the liquidation grace period of the given asset
   * @param asset The address of the underlying asset
   * @return Timestamp when the liquidation grace period will end
   **/
  function getLiquidationGracePeriod(address asset) external returns (uint40);

  /**
   * @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;

  /**
   * @notice Gets the address of the external FlashLoanLogic
   */
  function getFlashLoanLogic() external view returns (address);

  /**
   * @notice Gets the address of the external BorrowLogic
   */
  function getBorrowLogic() external view returns (address);

  /**
   * @notice Gets the address of the external BridgeLogic
   */
  function getBridgeLogic() external view returns (address);

  /**
   * @notice Gets the address of the external EModeLogic
   */
  function getEModeLogic() external view returns (address);

  /**
   * @notice Gets the address of the external LiquidationLogic
   */
  function getLiquidationLogic() external view returns (address);

  /**
   * @notice Gets the address of the external PoolLogic
   */
  function getPoolLogic() external view returns (address);

  /**
   * @notice Gets the address of the external SupplyLogic
   */
  function getSupplyLogic() external view returns (address);
}

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

import {IPriceOracleGetter} from './IPriceOracleGetter.sol';
import {IPoolAddressesProvider} from './IPoolAddressesProvider.sol';

/**
 * @title IAaveOracle
 * @author Aave
 * @notice Defines the basic interface for the Aave Oracle
 */
interface IAaveOracle is IPriceOracleGetter {
  /**
   * @dev Emitted after the base currency is set
   * @param baseCurrency The base currency of used for price quotes
   * @param baseCurrencyUnit The unit of the base currency
   */
  event BaseCurrencySet(address indexed baseCurrency, uint256 baseCurrencyUnit);

  /**
   * @dev Emitted after the price source of an asset is updated
   * @param asset The address of the asset
   * @param source The price source of the asset
   */
  event AssetSourceUpdated(address indexed asset, address indexed source);

  /**
   * @dev Emitted after the address of fallback oracle is updated
   * @param fallbackOracle The address of the fallback oracle
   */
  event FallbackOracleUpdated(address indexed fallbackOracle);

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

  /**
   * @notice Sets or replaces price sources of assets
   * @param assets The addresses of the assets
   * @param sources The addresses of the price sources
   */
  function setAssetSources(address[] calldata assets, address[] calldata sources) external;

  /**
   * @notice Sets the fallback oracle
   * @param fallbackOracle The address of the fallback oracle
   */
  function setFallbackOracle(address fallbackOracle) external;

  /**
   * @notice Returns a list of prices from a list of assets addresses
   * @param assets The list of assets addresses
   * @return The prices of the given assets
   */
  function getAssetsPrices(address[] calldata assets) external view returns (uint256[] memory);

  /**
   * @notice Returns the address of the source for an asset address
   * @param asset The address of the asset
   * @return The address of the source
   */
  function getSourceOfAsset(address asset) external view returns (address);

  /**
   * @notice Returns the address of the fallback oracle
   * @return The address of the fallback oracle
   */
  function getFallbackOracle() external view returns (address);
}

// SPDX-License-Identifier: MIT
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
  // @notice there is an unoccupied hole of 1 bit at position 59 from pre 3.2 stableBorrowRateEnabled
  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
  // @notice there is an unoccupied hole of 8 bits from 168 to 176 left from pre 3.2 eModeCategory
  uint256 internal constant UNBACKED_MINT_CAP_MASK =         0xFFFFFFFFFFF000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
  uint256 internal constant DEBT_CEILING_MASK =              0xF0000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // prettier-ignore
  uint256 internal constant VIRTUAL_ACC_ACTIVE_MASK =        0xEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; // 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 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;
  //@notice there is an unoccupied hole of 8 bits from 168 to 176 left from pre 3.2 eModeCategory
  uint256 internal constant UNBACKED_MINT_CAP_START_BIT_POSITION = 176;
  uint256 internal constant DEBT_CEILING_START_BIT_POSITION = 212;
  uint256 internal constant VIRTUAL_ACC_START_BIT_POSITION = 252;

  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_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 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 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 Sets the virtual account active/not state of the reserve
   * @param self The reserve configuration
   * @param active The active state
   */
  function setVirtualAccActive(
    DataTypes.ReserveConfigurationMap memory self,
    bool active
  ) internal pure {
    self.data =
      (self.data & VIRTUAL_ACC_ACTIVE_MASK) |
      (uint256(active ? 1 : 0) << VIRTUAL_ACC_START_BIT_POSITION);
  }

  /**
   * @notice Gets the virtual account active/not state of the reserve
   * @dev The state should be true for all normal assets and should be false
   *  only in special cases (ex. GHO) where an asset is minted instead of supplied.
   * @param self The reserve configuration
   * @return The active state
   */
  function getIsVirtualAccActive(
    DataTypes.ReserveConfigurationMap memory self
  ) internal pure returns (bool) {
    return (self.data & ~VIRTUAL_ACC_ACTIVE_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 paused
   */
  function getFlags(
    DataTypes.ReserveConfigurationMap memory self
  ) internal pure returns (bool, bool, bool, bool) {
    uint256 dataLocal = self.data;

    return (
      (dataLocal & ~ACTIVE_MASK) != 0,
      (dataLocal & ~FROZEN_MASK) != 0,
      (dataLocal & ~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
   */
  function getParams(
    DataTypes.ReserveConfigurationMap memory self
  ) internal pure returns (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
    );
  }

  /**
   * @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: MIT
pragma solidity ^0.8.10;

import {IPool, IPoolAddressesProvider} from '../../../interfaces/IPool.sol';

interface IERC4626StataToken {
  struct SignatureParams {
    uint8 v;
    bytes32 r;
    bytes32 s;
  }

  error PoolAddressMismatch(address pool);

  error StaticATokenInvalidZeroShares();

  error OnlyPauseGuardian(address caller);

  /**
   * @notice The pool associated with the aToken.
   * @return The pool address.
   */
  function POOL() external view returns (IPool);

  /**
   * @notice The poolAddressesProvider associated with the pool.
   * @return The poolAddressesProvider address.
   */
  function POOL_ADDRESSES_PROVIDER() external view returns (IPoolAddressesProvider);

  /**
   * @notice Burns `shares` of static aToken, with receiver receiving the corresponding amount of aToken
   * @param shares The shares to withdraw, in static balance of StaticAToken
   * @param receiver The address that will receive the amount of `ASSET` withdrawn from the Aave protocol
   * @return amountToWithdraw: aToken send to `receiver`, dynamic balance
   **/
  function redeemATokens(
    uint256 shares,
    address receiver,
    address owner
  ) external returns (uint256);

  /**
   * @notice Deposits aTokens and mints static aTokens to msg.sender
   * @param assets The amount of aTokens to deposit (e.g. deposit of 100 aUSDC)
   * @param receiver The address that will receive the static aTokens
   * @return uint256 The amount of StaticAToken minted, static balance
   **/
  function depositATokens(uint256 assets, address receiver) external returns (uint256);

  /**
   * @notice Universal deposit method for proving aToken or underlying liquidity with permit
   * @param assets The amount of aTokens or underlying to deposit
   * @param receiver The address that will receive the static aTokens
   * @param deadline Must be a timestamp in the future
   * @param sig A `secp256k1` signature params from `msgSender()`
   * @return uint256 The amount of StaticAToken minted, static balance
   **/
  function depositWithPermit(
    uint256 assets,
    address receiver,
    uint256 deadline,
    SignatureParams memory sig,
    bool depositToAave
  ) external returns (uint256);

  /**
   * @notice The aToken used inside the 4626 vault.
   * @return address The aToken address.
   */
  function aToken() external view returns (address);

  /**
   * @notice Returns the current asset price of the stataToken.
   * The price is calculated as `underlying_price * exchangeRate`.
   * It is important to note that:
   * - `underlying_price` is the price obtained by the aave-oracle and is subject to it's internal pricing mechanisms.
   * - as the price is scaled over the exchangeRate, but maintains the same precision as the underlying the price might be underestimated by 1 unit.
   * - when pricing multiple `shares` as `shares * price` keep in mind that the error compounds.
   * @return price the current asset price.
   */
  function latestAnswer() external view returns (int256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

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 uint248 from uint256, reverting on
   * overflow (when the input is greater than largest uint248).
   *
   * Counterpart to Solidity's `uint248` operator.
   *
   * Requirements:
   *
   * - input must fit into 248 bits
   *
   * _Available since v4.7._
   */
  function toUint248(uint256 value) internal pure returns (uint248) {
    require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
    return uint248(value);
  }

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

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

  /**
   * @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
   *
   * _Available since v4.2._
   */
  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 uint216 from uint256, reverting on
   * overflow (when the input is greater than largest uint216).
   *
   * Counterpart to Solidity's `uint216` operator.
   *
   * Requirements:
   *
   * - input must fit into 216 bits
   *
   * _Available since v4.7._
   */
  function toUint216(uint256 value) internal pure returns (uint216) {
    require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
    return uint216(value);
  }

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

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

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

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

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

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

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

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

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

  /**
   * @dev Returns the downcasted uint136 from uint256, reverting on
   * overflow (when the input is greater than largest uint136).
   *
   * Counterpart to Solidity's `uint136` operator.
   *
   * Requirements:
   *
   * - input must fit into 136 bits
   *
   * _Available since v4.7._
   */
  function toUint136(uint256 value) internal pure returns (uint136) {
    require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
    return uint136(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
   *
   * _Available since v2.5._
   */
  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 uint120 from uint256, reverting on
   * overflow (when the input is greater than largest uint120).
   *
   * Counterpart to Solidity's `uint120` operator.
   *
   * Requirements:
   *
   * - input must fit into 120 bits
   *
   * _Available since v4.7._
   */
  function toUint120(uint256 value) internal pure returns (uint120) {
    require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
    return uint120(value);
  }

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

  /**
   * @dev Returns the downcasted uint104 from uint256, reverting on
   * overflow (when the input is greater than largest uint104).
   *
   * Counterpart to Solidity's `uint104` operator.
   *
   * Requirements:
   *
   * - input must fit into 104 bits
   *
   * _Available since v4.7._
   */
  function toUint104(uint256 value) internal pure returns (uint104) {
    require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
    return uint104(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
   *
   * _Available since v4.2._
   */
  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 uint88 from uint256, reverting on
   * overflow (when the input is greater than largest uint88).
   *
   * Counterpart to Solidity's `uint88` operator.
   *
   * Requirements:
   *
   * - input must fit into 88 bits
   *
   * _Available since v4.7._
   */
  function toUint88(uint256 value) internal pure returns (uint88) {
    require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
    return uint88(value);
  }

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

  /**
   * @dev Returns the downcasted uint72 from uint256, reverting on
   * overflow (when the input is greater than largest uint72).
   *
   * Counterpart to Solidity's `uint72` operator.
   *
   * Requirements:
   *
   * - input must fit into 72 bits
   *
   * _Available since v4.7._
   */
  function toUint72(uint256 value) internal pure returns (uint72) {
    require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
    return uint72(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
   *
   * _Available since v2.5._
   */
  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 uint56 from uint256, reverting on
   * overflow (when the input is greater than largest uint56).
   *
   * Counterpart to Solidity's `uint56` operator.
   *
   * Requirements:
   *
   * - input must fit into 56 bits
   *
   * _Available since v4.7._
   */
  function toUint56(uint256 value) internal pure returns (uint56) {
    require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
    return uint56(value);
  }

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

  /**
   * @dev Returns the downcasted uint40 from uint256, reverting on
   * overflow (when the input is greater than largest uint40).
   *
   * Counterpart to Solidity's `uint40` operator.
   *
   * Requirements:
   *
   * - input must fit into 40 bits
   *
   * _Available since v4.7._
   */
  function toUint40(uint256 value) internal pure returns (uint40) {
    require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
    return uint40(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
   *
   * _Available since v2.5._
   */
  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 uint24 from uint256, reverting on
   * overflow (when the input is greater than largest uint24).
   *
   * Counterpart to Solidity's `uint24` operator.
   *
   * Requirements:
   *
   * - input must fit into 24 bits
   *
   * _Available since v4.7._
   */
  function toUint24(uint256 value) internal pure returns (uint24) {
    require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
    return uint24(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
   *
   * _Available since v2.5._
   */
  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
   *
   * _Available since v2.5._
   */
  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.
   *
   * _Available since v3.0._
   */
  function toUint256(int256 value) internal pure returns (uint256) {
    require(value >= 0, 'SafeCast: value must be positive');
    return uint256(value);
  }

  /**
   * @dev Returns the downcasted int248 from int256, reverting on
   * overflow (when the input is less than smallest int248 or
   * greater than largest int248).
   *
   * Counterpart to Solidity's `int248` operator.
   *
   * Requirements:
   *
   * - input must fit into 248 bits
   *
   * _Available since v4.7._
   */
  function toInt248(int256 value) internal pure returns (int248 downcasted) {
    downcasted = int248(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
  }

  /**
   * @dev Returns the downcasted int240 from int256, reverting on
   * overflow (when the input is less than smallest int240 or
   * greater than largest int240).
   *
   * Counterpart to Solidity's `int240` operator.
   *
   * Requirements:
   *
   * - input must fit into 240 bits
   *
   * _Available since v4.7._
   */
  function toInt240(int256 value) internal pure returns (int240 downcasted) {
    downcasted = int240(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
  }

  /**
   * @dev Returns the downcasted int232 from int256, reverting on
   * overflow (when the input is less than smallest int232 or
   * greater than largest int232).
   *
   * Counterpart to Solidity's `int232` operator.
   *
   * Requirements:
   *
   * - input must fit into 232 bits
   *
   * _Available since v4.7._
   */
  function toInt232(int256 value) internal pure returns (int232 downcasted) {
    downcasted = int232(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
  }

  /**
   * @dev Returns the downcasted int224 from int256, reverting on
   * overflow (when the input is less than smallest int224 or
   * greater than largest int224).
   *
   * Counterpart to Solidity's `int224` operator.
   *
   * Requirements:
   *
   * - input must fit into 224 bits
   *
   * _Available since v4.7._
   */
  function toInt224(int256 value) internal pure returns (int224 downcasted) {
    downcasted = int224(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
  }

  /**
   * @dev Returns the downcasted int216 from int256, reverting on
   * overflow (when the input is less than smallest int216 or
   * greater than largest int216).
   *
   * Counterpart to Solidity's `int216` operator.
   *
   * Requirements:
   *
   * - input must fit into 216 bits
   *
   * _Available since v4.7._
   */
  function toInt216(int256 value) internal pure returns (int216 downcasted) {
    downcasted = int216(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
  }

  /**
   * @dev Returns the downcasted int208 from int256, reverting on
   * overflow (when the input is less than smallest int208 or
   * greater than largest int208).
   *
   * Counterpart to Solidity's `int208` operator.
   *
   * Requirements:
   *
   * - input must fit into 208 bits
   *
   * _Available since v4.7._
   */
  function toInt208(int256 value) internal pure returns (int208 downcasted) {
    downcasted = int208(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
  }

  /**
   * @dev Returns the downcasted int200 from int256, reverting on
   * overflow (when the input is less than smallest int200 or
   * greater than largest int200).
   *
   * Counterpart to Solidity's `int200` operator.
   *
   * Requirements:
   *
   * - input must fit into 200 bits
   *
   * _Available since v4.7._
   */
  function toInt200(int256 value) internal pure returns (int200 downcasted) {
    downcasted = int200(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
  }

  /**
   * @dev Returns the downcasted int192 from int256, reverting on
   * overflow (when the input is less than smallest int192 or
   * greater than largest int192).
   *
   * Counterpart to Solidity's `int192` operator.
   *
   * Requirements:
   *
   * - input must fit into 192 bits
   *
   * _Available since v4.7._
   */
  function toInt192(int256 value) internal pure returns (int192 downcasted) {
    downcasted = int192(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
  }

  /**
   * @dev Returns the downcasted int184 from int256, reverting on
   * overflow (when the input is less than smallest int184 or
   * greater than largest int184).
   *
   * Counterpart to Solidity's `int184` operator.
   *
   * Requirements:
   *
   * - input must fit into 184 bits
   *
   * _Available since v4.7._
   */
  function toInt184(int256 value) internal pure returns (int184 downcasted) {
    downcasted = int184(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
  }

  /**
   * @dev Returns the downcasted int176 from int256, reverting on
   * overflow (when the input is less than smallest int176 or
   * greater than largest int176).
   *
   * Counterpart to Solidity's `int176` operator.
   *
   * Requirements:
   *
   * - input must fit into 176 bits
   *
   * _Available since v4.7._
   */
  function toInt176(int256 value) internal pure returns (int176 downcasted) {
    downcasted = int176(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
  }

  /**
   * @dev Returns the downcasted int168 from int256, reverting on
   * overflow (when the input is less than smallest int168 or
   * greater than largest int168).
   *
   * Counterpart to Solidity's `int168` operator.
   *
   * Requirements:
   *
   * - input must fit into 168 bits
   *
   * _Available since v4.7._
   */
  function toInt168(int256 value) internal pure returns (int168 downcasted) {
    downcasted = int168(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
  }

  /**
   * @dev Returns the downcasted int160 from int256, reverting on
   * overflow (when the input is less than smallest int160 or
   * greater than largest int160).
   *
   * Counterpart to Solidity's `int160` operator.
   *
   * Requirements:
   *
   * - input must fit into 160 bits
   *
   * _Available since v4.7._
   */
  function toInt160(int256 value) internal pure returns (int160 downcasted) {
    downcasted = int160(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
  }

  /**
   * @dev Returns the downcasted int152 from int256, reverting on
   * overflow (when the input is less than smallest int152 or
   * greater than largest int152).
   *
   * Counterpart to Solidity's `int152` operator.
   *
   * Requirements:
   *
   * - input must fit into 152 bits
   *
   * _Available since v4.7._
   */
  function toInt152(int256 value) internal pure returns (int152 downcasted) {
    downcasted = int152(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
  }

  /**
   * @dev Returns the downcasted int144 from int256, reverting on
   * overflow (when the input is less than smallest int144 or
   * greater than largest int144).
   *
   * Counterpart to Solidity's `int144` operator.
   *
   * Requirements:
   *
   * - input must fit into 144 bits
   *
   * _Available since v4.7._
   */
  function toInt144(int256 value) internal pure returns (int144 downcasted) {
    downcasted = int144(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
  }

  /**
   * @dev Returns the downcasted int136 from int256, reverting on
   * overflow (when the input is less than smallest int136 or
   * greater than largest int136).
   *
   * Counterpart to Solidity's `int136` operator.
   *
   * Requirements:
   *
   * - input must fit into 136 bits
   *
   * _Available since v4.7._
   */
  function toInt136(int256 value) internal pure returns (int136 downcasted) {
    downcasted = int136(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
  }

  /**
   * @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 downcasted) {
    downcasted = int128(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
  }

  /**
   * @dev Returns the downcasted int120 from int256, reverting on
   * overflow (when the input is less than smallest int120 or
   * greater than largest int120).
   *
   * Counterpart to Solidity's `int120` operator.
   *
   * Requirements:
   *
   * - input must fit into 120 bits
   *
   * _Available since v4.7._
   */
  function toInt120(int256 value) internal pure returns (int120 downcasted) {
    downcasted = int120(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
  }

  /**
   * @dev Returns the downcasted int112 from int256, reverting on
   * overflow (when the input is less than smallest int112 or
   * greater than largest int112).
   *
   * Counterpart to Solidity's `int112` operator.
   *
   * Requirements:
   *
   * - input must fit into 112 bits
   *
   * _Available since v4.7._
   */
  function toInt112(int256 value) internal pure returns (int112 downcasted) {
    downcasted = int112(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
  }

  /**
   * @dev Returns the downcasted int104 from int256, reverting on
   * overflow (when the input is less than smallest int104 or
   * greater than largest int104).
   *
   * Counterpart to Solidity's `int104` operator.
   *
   * Requirements:
   *
   * - input must fit into 104 bits
   *
   * _Available since v4.7._
   */
  function toInt104(int256 value) internal pure returns (int104 downcasted) {
    downcasted = int104(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
  }

  /**
   * @dev Returns the downcasted int96 from int256, reverting on
   * overflow (when the input is less than smallest int96 or
   * greater than largest int96).
   *
   * Counterpart to Solidity's `int96` operator.
   *
   * Requirements:
   *
   * - input must fit into 96 bits
   *
   * _Available since v4.7._
   */
  function toInt96(int256 value) internal pure returns (int96 downcasted) {
    downcasted = int96(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
  }

  /**
   * @dev Returns the downcasted int88 from int256, reverting on
   * overflow (when the input is less than smallest int88 or
   * greater than largest int88).
   *
   * Counterpart to Solidity's `int88` operator.
   *
   * Requirements:
   *
   * - input must fit into 88 bits
   *
   * _Available since v4.7._
   */
  function toInt88(int256 value) internal pure returns (int88 downcasted) {
    downcasted = int88(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
  }

  /**
   * @dev Returns the downcasted int80 from int256, reverting on
   * overflow (when the input is less than smallest int80 or
   * greater than largest int80).
   *
   * Counterpart to Solidity's `int80` operator.
   *
   * Requirements:
   *
   * - input must fit into 80 bits
   *
   * _Available since v4.7._
   */
  function toInt80(int256 value) internal pure returns (int80 downcasted) {
    downcasted = int80(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
  }

  /**
   * @dev Returns the downcasted int72 from int256, reverting on
   * overflow (when the input is less than smallest int72 or
   * greater than largest int72).
   *
   * Counterpart to Solidity's `int72` operator.
   *
   * Requirements:
   *
   * - input must fit into 72 bits
   *
   * _Available since v4.7._
   */
  function toInt72(int256 value) internal pure returns (int72 downcasted) {
    downcasted = int72(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
  }

  /**
   * @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 downcasted) {
    downcasted = int64(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
  }

  /**
   * @dev Returns the downcasted int56 from int256, reverting on
   * overflow (when the input is less than smallest int56 or
   * greater than largest int56).
   *
   * Counterpart to Solidity's `int56` operator.
   *
   * Requirements:
   *
   * - input must fit into 56 bits
   *
   * _Available since v4.7._
   */
  function toInt56(int256 value) internal pure returns (int56 downcasted) {
    downcasted = int56(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
  }

  /**
   * @dev Returns the downcasted int48 from int256, reverting on
   * overflow (when the input is less than smallest int48 or
   * greater than largest int48).
   *
   * Counterpart to Solidity's `int48` operator.
   *
   * Requirements:
   *
   * - input must fit into 48 bits
   *
   * _Available since v4.7._
   */
  function toInt48(int256 value) internal pure returns (int48 downcasted) {
    downcasted = int48(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
  }

  /**
   * @dev Returns the downcasted int40 from int256, reverting on
   * overflow (when the input is less than smallest int40 or
   * greater than largest int40).
   *
   * Counterpart to Solidity's `int40` operator.
   *
   * Requirements:
   *
   * - input must fit into 40 bits
   *
   * _Available since v4.7._
   */
  function toInt40(int256 value) internal pure returns (int40 downcasted) {
    downcasted = int40(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
  }

  /**
   * @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 downcasted) {
    downcasted = int32(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
  }

  /**
   * @dev Returns the downcasted int24 from int256, reverting on
   * overflow (when the input is less than smallest int24 or
   * greater than largest int24).
   *
   * Counterpart to Solidity's `int24` operator.
   *
   * Requirements:
   *
   * - input must fit into 24 bits
   *
   * _Available since v4.7._
   */
  function toInt24(int256 value) internal pure returns (int24 downcasted) {
    downcasted = int24(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
  }

  /**
   * @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 downcasted) {
    downcasted = int16(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
  }

  /**
   * @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 downcasted) {
    downcasted = int8(value);
    require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
  }

  /**
   * @dev Converts an unsigned uint256 into a signed int256.
   *
   * Requirements:
   *
   * - input must be less than or equal to maxInt256.
   *
   * _Available since v3.0._
   */
  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
pragma solidity ^0.8.10;

import {IRewardsDistributor} from './IRewardsDistributor.sol';
import {ITransferStrategyBase} from './ITransferStrategyBase.sol';
import {IEACAggregatorProxy} from '../../helpers/interfaces/IEACAggregatorProxy.sol';
import {RewardsDataTypes} from '../libraries/RewardsDataTypes.sol';

/**
 * @title IRewardsController
 * @author Aave
 * @notice Defines the basic interface for a Rewards Controller.
 */
interface IRewardsController is IRewardsDistributor {
  /**
   * @dev Emitted when a new address is whitelisted as claimer of rewards on behalf of a user
   * @param user The address of the user
   * @param claimer The address of the claimer
   */
  event ClaimerSet(address indexed user, address indexed claimer);

  /**
   * @dev Emitted when rewards are claimed
   * @param user The address of the user rewards has been claimed on behalf of
   * @param reward The address of the token reward is claimed
   * @param to The address of the receiver of the rewards
   * @param claimer The address of the claimer
   * @param amount The amount of rewards claimed
   */
  event RewardsClaimed(
    address indexed user,
    address indexed reward,
    address indexed to,
    address claimer,
    uint256 amount
  );

  /**
   * @dev Emitted when a transfer strategy is installed for the reward distribution
   * @param reward The address of the token reward
   * @param transferStrategy The address of TransferStrategy contract
   */
  event TransferStrategyInstalled(address indexed reward, address indexed transferStrategy);

  /**
   * @dev Emitted when the reward oracle is updated
   * @param reward The address of the token reward
   * @param rewardOracle The address of oracle
   */
  event RewardOracleUpdated(address indexed reward, address indexed rewardOracle);

  /**
   * @dev Whitelists an address to claim the rewards on behalf of another address
   * @param user The address of the user
   * @param claimer The address of the claimer
   */
  function setClaimer(address user, address claimer) external;

  /**
   * @dev Sets a TransferStrategy logic contract that determines the logic of the rewards transfer
   * @param reward The address of the reward token
   * @param transferStrategy The address of the TransferStrategy logic contract
   */
  function setTransferStrategy(address reward, ITransferStrategyBase transferStrategy) external;

  /**
   * @dev Sets an Aave Oracle contract to enforce rewards with a source of value.
   * @notice At the moment of reward configuration, the Incentives Controller performs
   * a check to see if the reward asset oracle is compatible with IEACAggregator proxy.
   * This check is enforced for integrators to be able to show incentives at
   * the current Aave UI without the need to setup an external price registry
   * @param reward The address of the reward to set the price aggregator
   * @param rewardOracle The address of price aggregator that follows IEACAggregatorProxy interface
   */
  function setRewardOracle(address reward, IEACAggregatorProxy rewardOracle) external;

  /**
   * @dev Get the price aggregator oracle address
   * @param reward The address of the reward
   * @return The price oracle of the reward
   */
  function getRewardOracle(address reward) external view returns (address);

  /**
   * @dev Returns the whitelisted claimer for a certain address (0x0 if not set)
   * @param user The address of the user
   * @return The claimer address
   */
  function getClaimer(address user) external view returns (address);

  /**
   * @dev Returns the Transfer Strategy implementation contract address being used for a reward address
   * @param reward The address of the reward
   * @return The address of the TransferStrategy contract
   */
  function getTransferStrategy(address reward) external view returns (address);

  /**
   * @dev Configure assets to incentivize with an emission of rewards per second until the end of distribution.
   * @param config The assets configuration input, the list of structs contains the following fields:
   *   uint104 emissionPerSecond: The emission per second following rewards unit decimals.
   *   uint256 totalSupply: The total supply of the asset to incentivize
   *   uint40 distributionEnd: The end of the distribution of the incentives for an asset
   *   address asset: The asset address to incentivize
   *   address reward: The reward token address
   *   ITransferStrategy transferStrategy: The TransferStrategy address with the install hook and claim logic.
   *   IEACAggregatorProxy rewardOracle: The Price Oracle of a reward to visualize the incentives at the UI Frontend.
   *                                     Must follow Chainlink Aggregator IEACAggregatorProxy interface to be compatible.
   */
  function configureAssets(RewardsDataTypes.RewardsConfigInput[] memory config) external;

  /**
   * @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;

  /**
   * @dev Claims reward for a user to the desired address, on all the assets of the pool, accumulating the pending rewards
   * @param assets List of assets to check eligible distributions before claiming rewards
   * @param amount The amount of rewards to claim
   * @param to The address that will be receiving the rewards
   * @param reward The address of the reward token
   * @return The amount of rewards claimed
   **/
  function claimRewards(
    address[] calldata assets,
    uint256 amount,
    address to,
    address reward
  ) external returns (uint256);

  /**
   * @dev Claims reward for a user on behalf, on all the assets of the pool, accumulating the pending rewards. The
   * caller must be whitelisted via "allowClaimOnBehalf" function by the RewardsAdmin role manager
   * @param assets The list of assets to check eligible distributions before claiming rewards
   * @param amount The amount of rewards to claim
   * @param user The address to check and claim rewards
   * @param to The address that will be receiving the rewards
   * @param reward The address of the reward token
   * @return The amount of rewards claimed
   **/
  function claimRewardsOnBehalf(
    address[] calldata assets,
    uint256 amount,
    address user,
    address to,
    address reward
  ) external returns (uint256);

  /**
   * @dev Claims reward for msg.sender, on all the assets of the pool, accumulating the pending rewards
   * @param assets The list of assets to check eligible distributions before claiming rewards
   * @param amount The amount of rewards to claim
   * @param reward The address of the reward token
   * @return The amount of rewards claimed
   **/
  function claimRewardsToSelf(
    address[] calldata assets,
    uint256 amount,
    address reward
  ) external returns (uint256);

  /**
   * @dev Claims all rewards for a user to the desired address, on all the assets of the pool, accumulating the pending rewards
   * @param assets The list of assets to check eligible distributions before claiming rewards
   * @param to The address that will be receiving the rewards
   * @return rewardsList List of addresses of the reward tokens
   * @return claimedAmounts List that contains the claimed amount per reward, following same order as "rewardList"
   **/
  function claimAllRewards(
    address[] calldata assets,
    address to
  ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts);

  /**
   * @dev Claims all rewards for a user on behalf, on all the assets of the pool, accumulating the pending rewards. The caller must
   * be whitelisted via "allowClaimOnBehalf" function by the RewardsAdmin role manager
   * @param assets The list of assets to check eligible distributions before claiming rewards
   * @param user The address to check and claim rewards
   * @param to The address that will be receiving the rewards
   * @return rewardsList List of addresses of the reward tokens
   * @return claimedAmounts List that contains the claimed amount per reward, following same order as "rewardsList"
   **/
  function claimAllRewardsOnBehalf(
    address[] calldata assets,
    address user,
    address to
  ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts);

  /**
   * @dev Claims all reward for msg.sender, on all the assets of the pool, accumulating the pending rewards
   * @param assets The list of assets to check eligible distributions before claiming rewards
   * @return rewardsList List of addresses of the reward tokens
   * @return claimedAmounts List that contains the claimed amount per reward, following same order as "rewardsList"
   **/
  function claimAllRewardsToSelf(
    address[] calldata assets
  ) external returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
}

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

interface IERC20AaveLM {
  struct UserRewardsData {
    uint128 rewardsIndexOnLastInteraction;
    uint128 unclaimedRewards;
  }

  struct RewardIndexCache {
    bool isRegistered;
    uint248 lastUpdatedIndex;
  }

  error ZeroIncentivesControllerIsForbidden();
  error InvalidClaimer(address claimer);
  error RewardNotInitialized(address reward);

  event RewardTokenRegistered(address indexed reward, uint256 startIndex);

  /**
   * @notice Claims rewards from `INCENTIVES_CONTROLLER` and updates internal accounting of rewards.
   * @param reward The reward to claim
   * @return uint256 Amount collected
   */
  function collectAndUpdateRewards(address reward) external returns (uint256);

  /**
   * @notice Claim rewards on behalf of a user and send them to a receiver
   * @dev Only callable by if sender is onBehalfOf or sender is approved claimer
   * @param onBehalfOf The address to claim on behalf of
   * @param receiver The address to receive the rewards
   * @param rewards The rewards to claim
   */
  function claimRewardsOnBehalf(
    address onBehalfOf,
    address receiver,
    address[] memory rewards
  ) external;

  /**
   * @notice Claim rewards and send them to a receiver
   * @param receiver The address to receive the rewards
   * @param rewards The rewards to claim
   */
  function claimRewards(address receiver, address[] memory rewards) external;

  /**
   * @notice Claim rewards
   * @param rewards The rewards to claim
   */
  function claimRewardsToSelf(address[] memory rewards) external;

  /**
   * @notice Get the total claimable rewards of the contract.
   * @param reward The reward to claim
   * @return uint256 The current balance + pending rewards from the `_incentivesController`
   */
  function getTotalClaimableRewards(address reward) external view returns (uint256);

  /**
   * @notice Get the total claimable rewards for a user in asset decimals
   * @param user The address of the user
   * @param reward The reward to claim
   * @return uint256 The claimable amount of rewards in asset decimals
   */
  function getClaimableRewards(address user, address reward) external view returns (uint256);

  /**
   * @notice The unclaimed rewards for a user in asset decimals
   * @param user The address of the user
   * @param reward The reward to claim
   * @return uint256 The unclaimed amount of rewards in asset decimals
   */
  function getUnclaimedRewards(address user, address reward) external view returns (uint256);

  /**
   * @notice The underlying asset reward index in RAY
   * @param reward The reward to claim
   * @return uint256 The underlying asset reward index in RAY
   */
  function getCurrentRewardsIndex(address reward) external view returns (uint256);

  /**
   * @notice Returns reference a/v token address used on INCENTIVES_CONTROLLER for tracking
   * @return address of reference token
   */
  function getReferenceAsset() external view returns (address);

  /**
   * @notice The IERC20s that are currently rewarded to addresses of the vault via LM on incentivescontroller.
   * @return IERC20 The IERC20s of the rewards.
   */
  function rewardTokens() external view returns (address[] memory);

  /**
   * @notice Fetches all rewardTokens from the incentivecontroller and registers the missing ones.
   */
  function refreshRewardTokens() external;

  /**
   * @notice Checks if the passed token is a registered reward.
   * @param reward The reward to claim
   * @return bool signaling if token is a registered reward.
   */
  function isRegisteredRewardToken(address reward) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4626.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";

/**
 * @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
 * https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
 */
interface IERC4626 is IERC20, IERC20Metadata {
    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

    event Withdraw(
        address indexed sender,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function asset() external view returns (address assetTokenAddress);

    /**
     * @dev Returns the total amount of the underlying asset that is “managed” by Vault.
     *
     * - SHOULD include any compounding that occurs from yield.
     * - MUST be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT revert.
     */
    function totalAssets() external view returns (uint256 totalManagedAssets);

    /**
     * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToShares(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToAssets(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
     * through a deposit call.
     *
     * - MUST return a limited value if receiver is subject to some deposit limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
     * - MUST NOT revert.
     */
    function maxDeposit(address receiver) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
     *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
     *   in the same transaction.
     * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
     *   deposit would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewDeposit(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   deposit execution, and are accounted for during deposit.
     * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
     * - MUST return a limited value if receiver is subject to some mint limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
     * - MUST NOT revert.
     */
    function maxMint(address receiver) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
     *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
     *   same transaction.
     * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
     *   would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by minting.
     */
    function previewMint(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
     *   execution, and are accounted for during mint.
     * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function mint(uint256 shares, address receiver) external returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
     * Vault, through a withdraw call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxWithdraw(address owner) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
     *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
     *   called
     *   in the same transaction.
     * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
     *   the withdrawal would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewWithdraw(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   withdraw execution, and are accounted for during withdraw.
     * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
     * through a redeem call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxRedeem(address owner) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
     *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
     *   same transaction.
     * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
     *   redemption would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by redeeming.
     */
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   redeem execution, and are accounted for during redeem.
     * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.20;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)
// Modified from https://github.com/OpenZeppelin/openzeppelin-contracts/commit/00cbf5a236564c3b7aacdad1f378cae22d890ca6
pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
  /**
   * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external;

  /**
   * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
  function nonces(address owner) external view returns (uint256);

  /**
   * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
  // solhint-disable-next-line func-name-mixedcase
  function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
// From commit https://github.com/OpenZeppelin/openzeppelin-contracts/commit/8b778fa20d6d76340c5fac1ed66c80273f05b95a

pragma solidity ^0.8.1;

/**
 * @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
   * ====
   *
   * [IMPORTANT]
   * ====
   * You shouldn't rely on `isContract` to protect against flash loan attacks!
   *
   * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
   * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
   * constructor.
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // This method relies on extcodesize/address.code.length, which returns 0
    // for contracts in construction, since the code is only stored at the end
    // of the constructor execution.

    return account.code.length > 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 functionCallWithValue(target, data, 0, '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');
    (bool success, bytes memory returndata) = target.call{value: value}(data);
    return verifyCallResultFromTarget(target, 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) {
    (bool success, bytes memory returndata) = target.staticcall(data);
    return verifyCallResultFromTarget(target, 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) {
    (bool success, bytes memory returndata) = target.delegatecall(data);
    return verifyCallResultFromTarget(target, success, returndata, errorMessage);
  }

  /**
   * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
   * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
   *
   * _Available since v4.8._
   */
  function verifyCallResultFromTarget(
    address target,
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) internal view returns (bytes memory) {
    if (success) {
      if (returndata.length == 0) {
        // only check isContract if the call was successful and the return data is empty
        // otherwise we already know that it was a contract
        require(isContract(target), 'Address: call to non-contract');
      }
      return returndata;
    } else {
      _revert(returndata, errorMessage);
    }
  }

  /**
   * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
   * revert reason or 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 {
      _revert(returndata, errorMessage);
    }
  }

  function _revert(bytes memory returndata, string memory errorMessage) private pure {
    // 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
      /// @solidity memory-safe-assembly
      assembly {
        let returndata_size := mload(returndata)
        revert(add(32, returndata), returndata_size)
      }
    } else {
      revert(errorMessage);
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

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

library DataTypes {
  /**
   * This exists specifically to maintain the `getReserveData()` interface, since the new, internal
   * `ReserveData` struct includes the reserve's `virtualUnderlyingBalance`.
   */
  struct ReserveDataLegacy {
    //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;
    // DEPRECATED on v3.2.0
    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;
    // DEPRECATED on v3.2.0
    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 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;
    // DEPRECATED on v3.2.0
    uint128 __deprecatedStableBorrowRate;
    //timestamp of last update
    uint40 lastUpdateTimestamp;
    //the id of the reserve. Represents the position in the list of the active reserves
    uint16 id;
    //timestamp until when liquidations are not allowed on the reserve, if set to past liquidations will be allowed
    uint40 liquidationGracePeriodUntil;
    //aToken address
    address aTokenAddress;
    // DEPRECATED on v3.2.0
    address __deprecatedStableDebtTokenAddress;
    //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;
    //the amount of underlying accounted for by the protocol
    uint128 virtualUnderlyingBalance;
  }

  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: DEPRECATED: 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: DEPRECATED: 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: virtual accounting is enabled for the reserve
    //bit 253-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;
  }

  // DEPRECATED: kept for backwards compatibility, might be removed in a future version
  struct EModeCategoryLegacy {
    // each eMode category has a custom ltv and liquidation threshold
    uint16 ltv;
    uint16 liquidationThreshold;
    uint16 liquidationBonus;
    // DEPRECATED
    address priceSource;
    string label;
  }

  struct CollateralConfig {
    uint16 ltv;
    uint16 liquidationThreshold;
    uint16 liquidationBonus;
  }

  struct EModeCategoryBaseConfiguration {
    uint16 ltv;
    uint16 liquidationThreshold;
    uint16 liquidationBonus;
    string label;
  }

  struct EModeCategory {
    // each eMode category has a custom ltv and liquidation threshold
    uint16 ltv;
    uint16 liquidationThreshold;
    uint16 liquidationBonus;
    uint128 collateralBitmap;
    string label;
    uint128 borrowableBitmap;
  }

  enum InterestRateMode {
    NONE,
    __DEPRECATED,
    VARIABLE
  }

  struct ReserveCache {
    uint256 currScaledVariableDebt;
    uint256 nextScaledVariableDebt;
    uint256 currLiquidityIndex;
    uint256 nextLiquidityIndex;
    uint256 currVariableBorrowIndex;
    uint256 nextVariableBorrowIndex;
    uint256 currLiquidityRate;
    uint256 currVariableBorrowRate;
    uint256 reserveFactor;
    ReserveConfigurationMap reserveConfiguration;
    address aTokenAddress;
    address variableDebtTokenAddress;
    uint40 reserveLastUpdateTimestamp;
  }

  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 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 reservesCount;
    address addressesProvider;
    address pool;
    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 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 totalDebt;
    uint256 reserveFactor;
    address reserve;
    bool usingVirtualBalance;
    uint256 virtualUnderlyingBalance;
  }

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

// SPDX-License-Identifier: MIT
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: MIT
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 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 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_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 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 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 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
  string public constant INVALID_MAX_RATE = '92'; // The expect maximum borrow rate is invalid
  string public constant WITHDRAW_TO_ATOKEN = '93'; // Withdrawing to the aToken is not allowed
  string public constant SUPPLY_TO_ATOKEN = '94'; // Supplying to the aToken is not allowed
  string public constant SLOPE_2_MUST_BE_GTE_SLOPE_1 = '95'; // Variable interest rate slope 2 can not be lower than slope 1
  string public constant CALLER_NOT_RISK_OR_POOL_OR_EMERGENCY_ADMIN = '96'; // 'The caller of the function is not a risk, pool or emergency admin'
  string public constant LIQUIDATION_GRACE_SENTINEL_CHECK_FAILED = '97'; // 'Liquidation grace sentinel validation failed'
  string public constant INVALID_GRACE_PERIOD = '98'; // Grace period above a valid range
  string public constant INVALID_FREEZE_STATE = '99'; // Reserve is already in the passed freeze state
  string public constant NOT_BORROWABLE_IN_EMODE = '100'; // Asset not borrowable in eMode
}

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

/**
 * @title IRewardsDistributor
 * @author Aave
 * @notice Defines the basic interface for a Rewards Distributor.
 */
interface IRewardsDistributor {
  /**
   * @dev Emitted when the configuration of the rewards of an asset is updated.
   * @param asset The address of the incentivized asset
   * @param reward The address of the reward token
   * @param oldEmission The old emissions per second value of the reward distribution
   * @param newEmission The new emissions per second value of the reward distribution
   * @param oldDistributionEnd The old end timestamp of the reward distribution
   * @param newDistributionEnd The new end timestamp of the reward distribution
   * @param assetIndex The index of the asset distribution
   */
  event AssetConfigUpdated(
    address indexed asset,
    address indexed reward,
    uint256 oldEmission,
    uint256 newEmission,
    uint256 oldDistributionEnd,
    uint256 newDistributionEnd,
    uint256 assetIndex
  );

  /**
   * @dev Emitted when rewards of an asset are accrued on behalf of a user.
   * @param asset The address of the incentivized asset
   * @param reward The address of the reward token
   * @param user The address of the user that rewards are accrued on behalf of
   * @param assetIndex The index of the asset distribution
   * @param userIndex The index of the asset distribution on behalf of the user
   * @param rewardsAccrued The amount of rewards accrued
   */
  event Accrued(
    address indexed asset,
    address indexed reward,
    address indexed user,
    uint256 assetIndex,
    uint256 userIndex,
    uint256 rewardsAccrued
  );

  /**
   * @dev Sets the end date for the distribution
   * @param asset The asset to incentivize
   * @param reward The reward token that incentives the asset
   * @param newDistributionEnd The end date of the incentivization, in unix time format
   **/
  function setDistributionEnd(address asset, address reward, uint32 newDistributionEnd) external;

  /**
   * @dev Sets the emission per second of a set of reward distributions
   * @param asset The asset is being incentivized
   * @param rewards List of reward addresses are being distributed
   * @param newEmissionsPerSecond List of new reward emissions per second
   */
  function setEmissionPerSecond(
    address asset,
    address[] calldata rewards,
    uint88[] calldata newEmissionsPerSecond
  ) external;

  /**
   * @dev Gets the end date for the distribution
   * @param asset The incentivized asset
   * @param reward The reward token of the incentivized asset
   * @return The timestamp with the end of the distribution, in unix time format
   **/
  function getDistributionEnd(address asset, address reward) external view returns (uint256);

  /**
   * @dev Returns the index of a user on a reward distribution
   * @param user Address of the user
   * @param asset The incentivized asset
   * @param reward The reward token of the incentivized asset
   * @return The current user asset index, not including new distributions
   **/
  function getUserAssetIndex(
    address user,
    address asset,
    address reward
  ) external view returns (uint256);

  /**
   * @dev Returns the configuration of the distribution reward for a certain asset
   * @param asset The incentivized asset
   * @param reward The reward token of the incentivized asset
   * @return The index of the asset distribution
   * @return The emission per second of the reward distribution
   * @return The timestamp of the last update of the index
   * @return The timestamp of the distribution end
   **/
  function getRewardsData(
    address asset,
    address reward
  ) external view returns (uint256, uint256, uint256, uint256);

  /**
   * @dev Calculates the next value of an specific distribution index, with validations.
   * @param asset The incentivized asset
   * @param reward The reward token of the incentivized asset
   * @return The old index of the asset distribution
   * @return The new index of the asset distribution
   **/
  function getAssetIndex(address asset, address reward) external view returns (uint256, uint256);

  /**
   * @dev Returns the list of available reward token addresses of an incentivized asset
   * @param asset The incentivized asset
   * @return List of rewards addresses of the input asset
   **/
  function getRewardsByAsset(address asset) external view returns (address[] memory);

  /**
   * @dev Returns the list of available reward addresses
   * @return List of rewards supported in this contract
   **/
  function getRewardsList() external view returns (address[] memory);

  /**
   * @dev Returns the accrued rewards balance of a user, not including virtually accrued rewards since last distribution.
   * @param user The address of the user
   * @param reward The address of the reward token
   * @return Unclaimed rewards, not including new distributions
   **/
  function getUserAccruedRewards(address user, address reward) external view returns (uint256);

  /**
   * @dev Returns a single rewards balance of a user, including virtually accrued and unrealized claimable rewards.
   * @param assets List of incentivized assets to check eligible distributions
   * @param user The address of the user
   * @param reward The address of the reward token
   * @return The rewards amount
   **/
  function getUserRewards(
    address[] calldata assets,
    address user,
    address reward
  ) external view returns (uint256);

  /**
   * @dev Returns a list all rewards of a user, including already accrued and unrealized claimable rewards
   * @param assets List of incentivized assets to check eligible distributions
   * @param user The address of the user
   * @return The list of reward addresses
   * @return The list of unclaimed amount of rewards
   **/
  function getAllUserRewards(
    address[] calldata assets,
    address user
  ) external view returns (address[] memory, uint256[] memory);

  /**
   * @dev Returns the decimals of an asset to calculate the distribution delta
   * @param asset The address to retrieve decimals
   * @return The decimals of an underlying asset
   */
  function getAssetDecimals(address asset) external view returns (uint8);

  /**
   * @dev Returns the address of the emission manager
   * @return The address of the EmissionManager
   */
  function EMISSION_MANAGER() external view returns (address);

  /**
   * @dev Returns the address of the emission manager.
   * Deprecated: This getter is maintained for compatibility purposes. Use the `EMISSION_MANAGER()` function instead.
   * @return The address of the EmissionManager
   */
  function getEmissionManager() external view returns (address);
}

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

interface ITransferStrategyBase {
  event EmergencyWithdrawal(
    address indexed caller,
    address indexed token,
    address indexed to,
    uint256 amount
  );

  /**
   * @dev Perform custom transfer logic via delegate call from source contract to a TransferStrategy implementation
   * @param to Account to transfer rewards
   * @param reward Address of the reward token
   * @param amount Amount to transfer to the "to" address parameter
   * @return Returns true bool if transfer logic succeeds
   */
  function performTransfer(address to, address reward, uint256 amount) external returns (bool);

  /**
   * @return Returns the address of the Incentives Controller
   */
  function getIncentivesController() external view returns (address);

  /**
   * @return Returns the address of the Rewards admin
   */
  function getRewardsAdmin() external view returns (address);

  /**
   * @dev Perform an emergency token withdrawal only callable by the Rewards admin
   * @param token Address of the token to withdraw funds from this contract
   * @param to Address of the recipient of the withdrawal
   * @param amount Amount of the withdrawal
   */
  function emergencyWithdrawal(address token, address to, uint256 amount) external;
}

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

interface IEACAggregatorProxy {
  function decimals() external view returns (uint8);

  function latestAnswer() external view returns (int256);

  function latestTimestamp() external view returns (uint256);

  function latestRound() external view returns (uint256);

  function getAnswer(uint256 roundId) external view returns (int256);

  function getTimestamp(uint256 roundId) external view returns (uint256);

  event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 timestamp);
  event NewRound(uint256 indexed roundId, address indexed startedBy);
}

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

import {ITransferStrategyBase} from '../interfaces/ITransferStrategyBase.sol';
import {IEACAggregatorProxy} from '../../helpers/interfaces/IEACAggregatorProxy.sol';

library RewardsDataTypes {
  struct RewardsConfigInput {
    uint88 emissionPerSecond;
    uint256 totalSupply;
    uint32 distributionEnd;
    address asset;
    address reward;
    ITransferStrategyBase transferStrategy;
    IEACAggregatorProxy rewardOracle;
  }

  struct UserAssetBalance {
    address asset;
    uint256 userBalance;
    uint256 totalSupply;
  }

  struct UserData {
    // Liquidity index of the reward distribution for the user
    uint104 index;
    // Amount of accrued rewards for the user since last user index update
    uint128 accrued;
  }

  struct RewardData {
    // Liquidity index of the reward distribution
    uint104 index;
    // Amount of reward tokens distributed per second
    uint88 emissionPerSecond;
    // Timestamp of the last reward index update
    uint32 lastUpdateTimestamp;
    // The end of the distribution of rewards (in seconds)
    uint32 distributionEnd;
    // Map of user addresses and their rewards data (userAddress => userData)
    mapping(address => UserData) usersData;
  }

  struct AssetData {
    // Map of reward token addresses and their data (rewardTokenAddress => rewardData)
    mapping(address => RewardData) rewards;
    // List of reward token addresses for the asset
    mapping(uint128 => address) availableRewards;
    // Count of reward tokens for the asset
    uint128 availableRewardsCount;
    // Number of decimals of the asset
    uint8 decimals;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
     * representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

{
  "remappings": [
    "solidity-utils/=lib/solidity-utils/src/",
    "forge-std/=lib/forge-std/src/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "openzeppelin-contracts-upgradeable/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/",
    "@openzeppelin/contracts-upgradeable/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/",
    "erc4626-tests/=lib/solidity-utils/lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IPool","name":"pool","type":"address"},{"internalType":"contract IRewardsController","name":"rewardsController","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxDeposit","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxMint","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxRedeem","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxWithdraw","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"EthTransferFailed","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[{"internalType":"address","name":"claimer","type":"address"}],"name":"InvalidClaimer","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"MathOverflowedMulDiv","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"OnlyPauseGuardian","type":"error"},{"inputs":[],"name":"OnlyRescueGuardian","type":"error"},{"inputs":[{"internalType":"address","name":"pool","type":"address"}],"name":"PoolAddressMismatch","type":"error"},{"inputs":[{"internalType":"address","name":"reward","type":"address"}],"name":"RewardNotInitialized","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"StaticATokenInvalidZeroShares","type":"error"},{"inputs":[],"name":"ZeroIncentivesControllerIsForbidden","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20Rescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"NativeTokensRescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"reward","type":"address"},{"indexed":false,"internalType":"uint256","name":"startIndex","type":"uint256"}],"name":"RewardTokenRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INCENTIVES_CONTROLLER","outputs":[{"internalType":"contract IRewardsController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POOL","outputs":[{"internalType":"contract IPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POOL_ADDRESSES_PROVIDER","outputs":[{"internalType":"contract IPoolAddressesProvider","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"actor","type":"address"}],"name":"canPause","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address[]","name":"rewards","type":"address[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"onBehalfOf","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address[]","name":"rewards","type":"address[]"}],"name":"claimRewardsOnBehalf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"rewards","type":"address[]"}],"name":"claimRewardsToSelf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"reward","type":"address"}],"name":"collectAndUpdateRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"depositATokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct IERC4626StataToken.SignatureParams","name":"sig","type":"tuple"},{"internalType":"bool","name":"depositToAave","type":"bool"}],"name":"depositWithPermit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyEtherTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc20Token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyTokenTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"reward","type":"address"}],"name":"getClaimableRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reward","type":"address"}],"name":"getCurrentRewardsIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReferenceAsset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reward","type":"address"}],"name":"getTotalClaimableRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"reward","type":"address"}],"name":"getUnclaimedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"aToken","type":"address"},{"internalType":"string","name":"staticATokenName","type":"string"},{"internalType":"string","name":"staticATokenSymbol","type":"string"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"reward","type":"address"}],"name":"isRegisteredRewardToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"maxRescue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeemATokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"refreshRewardTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whoCanRescue","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000974e2b16ddbf0ae6f78b4534353c2871213f2dc9000000000000000000000000642a66ddf9fe1821634ad4d415e28dbc37dd64af

-----Decoded View---------------
Arg [0] : pool (address): 0x974E2B16ddbF0ae6F78b4534353c2871213f2Dc9
Arg [1] : rewardsController (address): 0x642A66DdF9FE1821634Ad4d415e28dBC37Dd64aF

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000974e2b16ddbf0ae6f78b4534353c2871213f2dc9
Arg [1] : 000000000000000000000000642a66ddf9fe1821634ad4d415e28dbc37dd64af

1289:3001:33:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5363:132:32;;;:::i;:::-;;;160:25:51;;;148:2;133:18;5363:132:32;;;;;;;;3011:144:1;;;:::i;:::-;;;;;;;:::i;7381:148:3:-;;;;;;:::i;:::-;;:::i;4483:253:32:-;;;;;;:::i;:::-;;:::i;5505:186:1:-;;;;;;:::i;:::-;;:::i;:::-;;;2219:14:51;;2212:22;2194:41;;2182:2;2167:18;5505:186:1;2054:187:51;8647:147:3;;;;;;:::i;:::-;;:::i;1724:57:31:-;;;;;;;;-1:-1:-1;;;;;2438:32:51;;;2420:51;;2408:2;2393:18;1724:57:31;2246:231:51;2161:111:33;;;;;;:::i;:::-;;:::i;:::-;;4191:152:1;4322:14;;4191:152;;2871:140:31;;;;;;:::i;:::-;;:::i;6251:244:1:-;;;;;;:::i;:::-;;:::i;3211:301:31:-;;;:::i;1904:63:32:-;;;;;3330:364:33;;;:::i;:::-;;;5811:4:51;5799:17;;;5781:36;;5769:2;5754:18;3330:364:33;5639:184:51;3082:112:2;;;:::i;6747:153:3:-;;;:::i;6380:1001:32:-;;;;;;:::i;:::-;;:::i;7421:330::-;;;:::i;1834:34::-;;1864:4;1834:34;;2692:145:6;-1:-1:-1;;;;;;;;;;;2821:9:6;;;2692:145;;4552:449:31;;;;;;:::i;:::-;;:::i;5514:157::-;;;:::i;9038:392:3:-;;;;;;:::i;:::-;;:::i;3965:198:31:-;;;;;;:::i;:::-;;:::i;4401:171:1:-;;;;;;:::i;:::-;;:::i;1873:27:32:-;;;;;2945:154:33;;;;;;:::i;:::-;;:::i;3133:161::-;;;;;;:::i;:::-;;:::i;5173:903:7:-;;;:::i;:::-;;;;;;;;;;;;;:::i;5261:219:31:-;;;;;;:::i;:::-;-1:-1:-1;;;;;5426:24:31;;;5343:7;5426:24;;;:18;:24;;;;;;;;:32;;;;;;;;;;;:49;-1:-1:-1;;;5426:49:31;;-1:-1:-1;;;;;5426:49:31;;5261:219;3045:132;;;;;;:::i;:::-;;:::i;1787:339:33:-;;;;;;:::i;:::-;;:::i;9697:380:3:-;;;;;;:::i;:::-;;:::i;3268:148:1:-;;;:::i;4776:157:32:-;;;:::i;654:190:27:-;;;;;;:::i;:::-;;:::i;2304:118:33:-;;;:::i;4767:178:1:-;;;;;;:::i;:::-;;:::i;8450:143:3:-;;;;;;:::i;:::-;;:::i;10124:413::-;;;;;;:::i;:::-;;:::i;10582:405::-;;;;;;:::i;:::-;;:::i;3546:385:31:-;;;;;;:::i;:::-;;:::i;5705:159::-;;;:::i;:::-;;;;;;;:::i;4963:214:32:-;;;;;;:::i;:::-;;:::i;7179:148:3:-;;;;;;:::i;:::-;;:::i;3496:947:32:-;;;;;;:::i;:::-;;:::i;5207:126::-;;;;;;:::i;:::-;;:::i;2095:672:2:-;;;;;;:::i;:::-;;:::i;2459:451:33:-;;;;;;:::i;:::-;;:::i;5525:825:32:-;;;;;;:::i;:::-;;:::i;5003:195:1:-;;;;;;:::i;:::-;;:::i;4197:321:31:-;;;;;;:::i;:::-;;:::i;2967:489:32:-;;;;;;:::i;:::-;;:::i;2474:363:31:-;;;;;;:::i;:::-;;:::i;877:142:27:-;;;;;;:::i;:::-;;:::i;5035:192:31:-;;;;;;:::i;:::-;;:::i;5363:132:32:-;5416:7;5438:52;5455:13;4322:14:1;;;4191:152;5455:13:32;5470:19;5438:16;:52::i;:::-;5431:59;;5363:132;:::o;3011:144:1:-;3056:13;3081:22;-1:-1:-1;;;;;;;;;;;3106:18:1;3081:43;;3141:1;:7;;3134:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3011:144;:::o;7381:148:3:-;7451:7;7477:45;7494:6;7502:19;7477:16;:45::i;:::-;7470:52;7381:148;-1:-1:-1;;7381:148:3:o;4483:253:32:-;4589:7;4604:14;4621:21;4635:6;4621:13;:21::i;:::-;4604:38;-1:-1:-1;4648:63:32;966:10:4;4672:8:32;4682:5;4689:6;4697;4705:5;4648:9;:63::i;:::-;4725:6;-1:-1:-1;4483:253:32;;;;;;:::o;5505:186:1:-;5578:4;966:10:4;5632:31:1;966:10:4;5648:7:1;5657:5;5632:8;:31::i;:::-;-1:-1:-1;5680:4:1;;5505:186;-1:-1:-1;;;5505:186:1:o;8647:147:3:-;8717:7;8743:44;8760:6;8768:18;8743:16;:44::i;2161:111:33:-;1709:22;966:10:4;2945:154:33;:::i;1709:22::-;1704:67;;1740:31;;-1:-1:-1;;;1740:31:33;;966:10:4;1740:31:33;;;2420:51:51;2393:18;;1740:31:33;;;;;;;;1704:67;2230:6:::1;2226:41;;;2238:8;:6;:8::i;:::-;2161:111:::0;:::o;2226:41::-:1;2257:10;:8;:10::i;2871:140:31:-:0;2952:54;966:10:4;2988:8:31;2998:7;2952:21;:54::i;:::-;2871:140;;:::o;6251:244:1:-;6338:4;966:10:4;6394:37:1;6410:4;966:10:4;6425:5:1;6394:15;:37::i;:::-;6441:26;6451:4;6457:2;6461:5;6441:9;:26::i;:::-;-1:-1:-1;6484:4:1;;6251:244;-1:-1:-1;;;;6251:244:1:o;3211:301:31:-;3264:28;-1:-1:-1;;;;;;;;;;;3392:17:31;;3352:58;;-1:-1:-1;;;3352:58:31;;-1:-1:-1;;;;;3392:17:31;;;3352:58;;;2420:51:51;3392:17:31;;-1:-1:-1;3325:24:31;;3352:21;:39;;;;;;2393:18:51;;3352:58:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;3352:58:31;;;;;;;;;;;;:::i;:::-;3325:85;;3421:9;3416:92;3440:7;:14;3436:1;:18;3416:92;;;3469:32;3490:7;3498:1;3490:10;;;;;;;;:::i;:::-;;;;;;;3469:20;:32::i;:::-;3456:3;;;;:::i;:::-;;;;3416:92;;;;3258:254;;3211:301::o;3330:364:33:-;3450:5;3660:29;:27;:29::i;3082:112:2:-;3141:7;3167:20;:18;:20::i;6747:153:3:-;6793:7;;4093:22;6839:20;6884:8;-1:-1:-1;;;;;6884:8:3;;6747:153;-1:-1:-1;;6747:153:3:o;6380:1001:32:-;6439:7;6454:46;6503:4;-1:-1:-1;;;;;6503:19:32;;6523:7;:5;:7::i;:::-;6503:28;;-1:-1:-1;;;;;;6503:28:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;6503:28:32;;;2420:51:51;2393:18;;6503:28:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6650:25;;9050:9:44;6650:25:32;;-1:-1:-1;;;;9050:24:44;9049:31;;6618:125:32;;-1:-1:-1;6717:25:32;;10332:9:44;-1:-1:-1;;;10332:24:44;10331:31;;6686:57:32;6618:192;;;-1:-1:-1;6784:25:32;;9691:9:44;9703:12;9691:24;9690:31;;6753:57:32;6607:233;;;-1:-1:-1;6832:1:32;;6380:1001;-1:-1:-1;;6380:1001:32:o;6607:233::-;6975:25;;8373:9:44;6846:17:32;;3487:2:44;8372:67;;;6936:65:32;;:2;:65;:::i;:::-;6900:25;;15924:9:44;4161:3;15923:63;;;6866:136:32;;;;:::i;:::-;6846:156;;7057:9;7070:1;7057:14;7053:44;;-1:-1:-1;;;7080:17:32;6380:1001;-1:-1:-1;;;6380:1001:32:o;7053:44::-;7146:21;7170:135;7272:7;:5;:7::i;:::-;1864:4;7286:18;7234:11;:29;;;-1:-1:-1;;;;;7171:92:32;7179:11;:25;;;-1:-1:-1;;;;;7171:52:32;;:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:92;;;;:::i;:::-;7170:101;:135;;:101;:135::i;:::-;7146:159;;7335:9;7318:13;:26;;:58;;7351:25;7363:13;7351:9;:25;:::i;:::-;7318:58;;;7347:1;7318:58;7311:65;6380:1001;-1:-1:-1;;;;;6380:1001:32:o;7421:330::-;7468:6;7482:34;7531:23;-1:-1:-1;;;;;7531:38:32;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;7519:74:32;;7594:7;:5;:7::i;:::-;7519:83;;-1:-1:-1;;;;;;7519:83:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;7519:83:32;;;2420:51:51;2393:18;;7519:83:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7482:120;;7677:68;7711:7;:5;:7::i;:::-;7677:26;;1864:4;7725:19;7677:33;:68::i;:::-;7663:83;;;7421:330;:::o;4552:449:31:-;4625:7;-1:-1:-1;;;;;4644:20:31;;4640:49;;-1:-1:-1;4681:1:31;;4552:449;-1:-1:-1;4552:449:31:o;4640:49::-;4782:16;;;4796:1;4782:16;;;;;;;;;-1:-1:-1;;;;;;;;;;;1684:26:31;4695:28;;4782:16;;;;;;;;;;-1:-1:-1;;4816:17:31;;4804:9;;;;-1:-1:-1;;;;;;4816:17:31;;4804:9;;-1:-1:-1;4816:17:31;;4804:9;;;;:::i;:::-;-1:-1:-1;;;;;4804:29:31;;;:9;;;;;;;;;:29;4862:67;;-1:-1:-1;;;4862:67:31;;4839:20;;4862:21;:36;;;;:67;;4899:6;;4915:4;;4922:6;;4862:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4942:39;;-1:-1:-1;;;4942:39:31;;4975:4;4942:39;;;2420:51:51;4839:90:31;;-1:-1:-1;4839:90:31;;-1:-1:-1;;;;;4942:24:31;;;;;2393:18:51;;4942:39:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:54;;;;:::i;5514:157::-;5566:7;;-1:-1:-1;;;;;;;;;;;5612:24:31;1565:155;9038:392:3;9113:7;9132:17;9152:20;9163:8;9152:10;:20::i;:::-;9132:40;;9195:9;9186:6;:18;9182:110;;;9253:8;9263:6;9271:9;9227:54;;-1:-1:-1;;;9227:54:3;;;;;;;;;;:::i;9182:110::-;9302:14;9319:22;9334:6;9319:14;:22::i;:::-;9302:39;-1:-1:-1;9351:48:3;966:10:4;9374:8:3;9384:6;9392;9351:8;:48::i;:::-;9417:6;9038:392;-1:-1:-1;;;;9038:392:3:o;3965:198:31:-;-1:-1:-1;;;;;4124:21:31;4044:4;4124:21;;;:13;:21;;;;;:34;;;;3965:198::o;4401:171:1:-;4466:7;;-1:-1:-1;;;;;;;;;;;4510:18:1;-1:-1:-1;;;;;4545:20:1;;;:11;:20;;;;;;;;-1:-1:-1;;4545:20:1;;;;;4401:171::o;2945:154:33:-;2999:4;3030:23;-1:-1:-1;;;;;3030:37:33;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3018:76;;-1:-1:-1;;;3018:76:33;;-1:-1:-1;;;;;2438:32:51;;;3018:76:33;;;2420:51:51;3018:69:33;;;;;;;2393:18:51;;3018:76:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;3133:161::-;3248:7;3270:19;3283:5;3270:12;:19::i;5173:903:7:-;5271:13;5298:18;;5271:13;;;5298:18;5271:13;-1:-1:-1;;;;;;;;;;;5777:13:7;;5511:45;;-1:-1:-1;5777:18:7;:43;;;;-1:-1:-1;5799:16:7;;;;:21;5777:43;5769:77;;;;-1:-1:-1;;;5769:77:7;;21798:2:51;5769:77:7;;;21780:21:51;21837:2;21817:18;;;21810:30;-1:-1:-1;;;21856:18:51;;;21849:51;21917:18;;5769:77:7;21596:345:51;5769:77:7;5908:13;:11;:13::i;:::-;5935:16;:14;:16::i;:::-;6043;;;6027:1;6043:16;;;;;;;;;-1:-1:-1;;;5857:212:7;;;-1:-1:-1;5857:212:7;;-1:-1:-1;5965:13:7;;-1:-1:-1;6000:4:7;;-1:-1:-1;6027:1:7;-1:-1:-1;6043:16:7;-1:-1:-1;5857:212:7;-1:-1:-1;;5173:903:7:o;3045:132:31:-;3114:58;966:10:4;;3164:7:31;3114:21;:58::i;1787:339:33:-;8870:21:0;4302:15;;-1:-1:-1;;;4302:15:0;;;;4301:16;;-1:-1:-1;;;;;4348:14:0;4158:30;4726:16;;:34;;;;;4746:14;4726:34;4706:54;;4770:17;4790:11;-1:-1:-1;;;;;4790:16:0;4805:1;4790:16;:50;;;;-1:-1:-1;4818:4:0;4810:25;:30;4790:50;4770:70;;4856:12;4855:13;:30;;;;;4873:12;4872:13;4855:30;4851:91;;;4908:23;;-1:-1:-1;;;4908:23:0;;;;;;;;;;;4851:91;4951:18;;-1:-1:-1;;4951:18:0;4968:1;4951:18;;;4979:67;;;;5013:22;;-1:-1:-1;;;;5013:22:0;-1:-1:-1;;;5013:22:0;;;4979:67;1936:50:33::1;1949:16;;1936:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;1936:50:33::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;-1:-1:-1;1967:18:33;;-1:-1:-1;1967:18:33;;;;1936:50;::::1;1967:18:::0;;;;1936:50;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;1936:12:33::1;::::0;-1:-1:-1;;;1936:50:33:i:1;:::-;1992:36;2011:16;;1992:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;1992:18:33::1;::::0;-1:-1:-1;;;1992:36:33:i:1;:::-;2034:26;2053:6;2034:18;:26::i;:::-;2066:32;2091:6;2066:24;:32::i;:::-;2104:17;:15;:17::i;:::-;5070:14:0::0;5066:101;;;5100:23;;-1:-1:-1;;;;5100:23:0;;;5142:14;;-1:-1:-1;22099:50:51;;5142:14:0;;22087:2:51;22072:18;5142:14:0;;;;;;;5066:101;4092:1081;;;;;1787:339:33;;;;;:::o;9697:380:3:-;9769:7;9788:17;9808;9816:8;9808:7;:17::i;:::-;9788:37;;9848:9;9839:6;:18;9835:107;;;9903:8;9913:6;9921:9;9880:51;;-1:-1:-1;;;9880:51:3;;;;;;;;;;:::i;9835:107::-;9952:14;9969:19;9981:6;9969:11;:19::i;:::-;9952:36;-1:-1:-1;9998:48:3;966:10:4;10021:8:3;10031:6;10039;9998:8;:48::i;3268:148:1:-;3400:9;3393:16;;3315:13;;-1:-1:-1;;;;;;;;;;;2359:20:1;3393:16;;;:::i;4776:157:32:-;4815:7;;-1:-1:-1;;;;;;;;;;;4867:30:32;1643:187;654:190:27;552:14;:12;:14::i;:::-;-1:-1:-1;;;;;538:28:27;:10;-1:-1:-1;;;;;538:28:27;;534:76;;583:20;;-1:-1:-1;;;583:20:27;;;;;;;;;;;534:76;792:47:::1;816:10;828:2;832:6;792:23;:47::i;2304:118:33:-:0;2358:7;2380:23;-1:-1:-1;;;;;2380:35:33;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;4767:178:1:-;4836:4;966:10:4;4890:27:1;966:10:4;4907:2:1;4911:5;4890:9;:27::i;8450:143:3:-;8516:7;8542:44;8559:6;8567:18;8542:16;:44::i;10124:413::-;10215:7;10234:17;10254:18;10266:5;10254:11;:18::i;:::-;10234:38;;10295:9;10286:6;:18;10282:108;;;10354:5;10361:6;10369:9;10327:52;;-1:-1:-1;;;10327:52:3;;;;;;;;;;:::i;10282:108::-;10400:14;10417:23;10433:6;10417:15;:23::i;:::-;10400:40;-1:-1:-1;10450:56:3;966:10:4;10474:8:3;10484:5;10491:6;10499;10450:9;:56::i;10582:405::-;10671:7;10690:17;10710:16;10720:5;10710:9;:16::i;:::-;10690:36;;10749:9;10740:6;:18;10736:106;;;10806:5;10813:6;10821:9;10781:50;;-1:-1:-1;;;10781:50:3;;;;;;;;;;:::i;10736:106::-;10852:14;10869:21;10883:6;10869:13;:21::i;:::-;10852:38;-1:-1:-1;10900:56:3;966:10:4;10924:8:3;10934:5;10941:6;10949;10900:9;:56::i;3546:385:31:-;3611:7;-1:-1:-1;;;;;3630:20:31;;3626:49;;-1:-1:-1;3667:1:31;;3546:385;-1:-1:-1;3546:385:31:o;3626:49::-;3768:16;;;3782:1;3768:16;;;;;;;;;-1:-1:-1;;;;;;;;;;;1684:26:31;3681:28;;3768:16;;;;;;;;;;-1:-1:-1;;3810:17:31;;3790:9;;;;-1:-1:-1;;;;;;3810:17:31;;3790:9;;-1:-1:-1;3810:17:31;;3790:9;;;;:::i;:::-;-1:-1:-1;;;;;3790:38:31;;;:9;;;;;;;;;:38;3842:84;;-1:-1:-1;;;3842:84:31;;:21;:34;;;;;;:84;;3877:6;;-1:-1:-1;;3885:17:31;3912:4;;3919:6;;3842:84;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;5705:159::-;5752:16;5776:28;-1:-1:-1;;;;;;;;;;;5844:15:31;;;5837:22;;;;;;;;;;;;;;;;;;;5776:55;;-1:-1:-1;5837:22:31;;5844:15;5837:22;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5837:22:31;;;;;;;;;;;;;;;;;;;;;;;5705:159;:::o;4963:214:32:-;5019:7;5034:14;5051:22;5070:1;5051:10;:22::i;:::-;5034:39;;-1:-1:-1;;5083:6:32;:27;5079:57;;-1:-1:-1;;;5119:17:32;4963:214;-1:-1:-1;;4963:214:32:o;5079:57::-;5149:23;5165:6;7179:148:3;7249:7;7275:45;7292:6;7300:19;7275:16;:45::i;3496:947:32:-;3665:7;3680:22;3705:13;:34;;3731:8;:6;:8::i;:::-;3705:34;;;3721:7;:5;:7::i;:::-;3680:59;-1:-1:-1;;;;;;3756:35:32;;;966:10:4;3880:5:32;;3895;;;;3910;;;;;3756:167;;;;;;-1:-1:-1;;;;;;3756:167:32;;;-1:-1:-1;;;;;23064:15:51;;;3756:167:32;;;23046:34:51;3831:4:32;23096:18:51;;;23089:43;23148:18;;;23141:34;;;23191:18;;;23184:34;;;23267:4;23255:17;;;23234:19;;;23227:46;23289:19;;;23282:35;23333:19;;;23326:35;22980:19;;3756:167:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3746:193;4152:25;-1:-1:-1;;;;;4180:32:32;;;966:10:4;4180:46:32;;-1:-1:-1;;;;;;4180:46:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;4180:46:32;;;2420:51:51;2393:18;;4180:46:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4152:74;;4245:17;4236:6;:26;4232:73;;;4281:17;4272:26;;4232:73;4311:14;4328:22;4343:6;4328:14;:22::i;:::-;4311:39;-1:-1:-1;4356:63:32;966:10:4;4379:8:32;4389:6;4397;4405:13;4356:8;:63::i;:::-;4432:6;3496:947;-1:-1:-1;;;;;;;;3496:947:32:o;5207:126::-;5273:7;5295:33;5311:16;5321:5;5311:9;:16::i;2095:672:2:-;2316:8;2298:15;:26;2294:97;;;2347:33;;-1:-1:-1;;;2347:33:2;;;;;160:25:51;;;133:18;;2347:33:2;14:177:51;2294:97:2;2401:18;1277:95;2460:5;2467:7;2476:5;2483:16;2493:5;-1:-1:-1;;;;;1954:16:5;1597:7;1954:16;;;1005:21;1954:16;;;;;:18;;;;;;;;;1537:452;2483:16:2;2432:78;;;;;;23659:25:51;;;;-1:-1:-1;;;;;23758:15:51;;;23738:18;;;23731:43;23810:15;;;;23790:18;;;23783:43;23842:18;;;23835:34;23885:19;;;23878:35;23929:19;;;23922:35;;;23631:19;;2432:78:2;;;;;;;;;;;;2422:89;;;;;;2401:110;;2522:12;2537:28;2554:10;2537:16;:28::i;:::-;2522:43;;2576:14;2593:28;2607:4;2613:1;2616;2619;2593:13;:28::i;:::-;2576:45;;2645:5;-1:-1:-1;;;;;2635:15:2;:6;-1:-1:-1;;;;;2635:15:2;;2631:88;;2673:35;;-1:-1:-1;;;2673:35:2;;-1:-1:-1;;;;;24198:15:51;;;2673:35:2;;;24180:34:51;24250:15;;24230:18;;;24223:43;24115:18;;2673:35:2;23968:304:51;2631:88:2;2729:31;2738:5;2745:7;2754:5;2729:8;:31::i;2459:451:33:-;2562:7;2577:20;2600:8;:6;:8::i;:::-;2577:31;;2627:12;-1:-1:-1;;;;;2618:21:33;:5;-1:-1:-1;;;;;2618:21:33;;2614:262;;2649:23;2675:51;2692:13;4322:14:1;;;4191:152;2692:13:33;2707:18;2675:16;:51::i;:::-;2752:45;;-1:-1:-1;;;2752:45:33;;2791:4;2752:45;;;2420:51:51;2649:77:33;;-1:-1:-1;2734:15:33;;-1:-1:-1;;;;;2752:30:33;;;;;2393:18:51;;2752:45:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2734:63;;2822:15;2812:7;:25;:57;;2868:1;2812:57;;;2840:25;2850:15;2840:7;:25;:::i;2614:262::-;-1:-1:-1;;;2888:17:33;2459:451;-1:-1:-1;;2459:451:33:o;5525:825:32:-;5589:7;5604:61;5668:4;-1:-1:-1;;;;;5668:21:32;;5690:7;:5;:7::i;:::-;5668:30;;-1:-1:-1;;;;;;5668:30:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;5668:30:32;;;2420:51:51;2393:18;;5668:30:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5604:94;;5779:52;5810:20;9050:9:44;-1:-1:-1;;;9050:24:44;9049:31;;;8941:144;5779:52:32;5778:53;:115;;;-1:-1:-1;10332:9:44;;-1:-1:-1;;;10332:24:44;10331:31;;5841:52:32;5767:156;;;-1:-1:-1;5915:1:32;;5525:825;-1:-1:-1;;5525:825:32:o;5767:156::-;5992:32;6027:4;-1:-1:-1;;;;;6027:32:32;;6060:7;:5;:7::i;:::-;6027:41;;-1:-1:-1;;;;;;6027:41:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;6027:41:32;;;2420:51:51;2393:18;;6027:41:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5992:76;;6074:38;6115:41;6131:24;-1:-1:-1;;;;;6115:41:32;:15;:41::i;:::-;6074:82;;6162:25;6190:16;6200:5;6190:9;:16::i;:::-;6162:44;;6259:17;6225:30;:51;;:120;;6315:30;6225:120;;;6287:17;6225:120;6212:133;5525:825;-1:-1:-1;;;;;;5525:825:32:o;5003:195:1:-;-1:-1:-1;;;;;5162:20:1;;;5083:7;5162:20;;;:13;:20;;;;;;;;:29;;;;;;;;;;;;;5003:195::o;4197:321:31:-;4266:7;-1:-1:-1;;;;;4285:29:31;;4281:58;;-1:-1:-1;4331:1:31;;4197:321;-1:-1:-1;4197:321:31:o;4281:58::-;-1:-1:-1;;;;;;;;;;;4465:17:31;;4429:62;;;-1:-1:-1;;;4429:62:31;;-1:-1:-1;;;;;4465:17:31;;;4429:62;;;24180:34:51;24250:15;;;24230:18;;;24223:43;4429:62:31;;4344:28;;4429:21;:35;;;;24115:18:51;;;;;4429:62:31;;;;;;:35;:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2967:489:32:-;3043:7;3178:25;3213:8;:6;:8::i;:::-;-1:-1:-1;;;;;3206:26:32;;966:10:4;3206:40:32;;-1:-1:-1;;;;;;3206:40:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;3206:40:32;;;2420:51:51;2393:18;;3206:40:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3178:68;;3265:17;3256:6;:26;3252:73;;;3301:17;3292:26;;3252:73;3331:14;3348:22;3363:6;3348:14;:22::i;:::-;3331:39;-1:-1:-1;3376:55:32;966:10:4;3399:8:32;3409:6;3417;3425:5;3376:8;:55::i;2474:363:31:-;966:10:4;-1:-1:-1;;;;;2641:23:31;;;;;;;:84;;-1:-1:-1;2681:44:31;;-1:-1:-1;;;2681:44:31;;-1:-1:-1;;;;;2438:32:51;;;2681:44:31;;;2420:51:51;2681:21:31;:32;;;;2393:18:51;;2681:44:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;2668:57:31;:9;-1:-1:-1;;;;;2668:57:31;;;2641:84;2637:137;;;2742:25;;-1:-1:-1;;;2742:25:31;;-1:-1:-1;;;;;2438:32:51;;2742:25:31;;;2420:51:51;2393:18;;2742:25:31;2246:231:51;2637:137:31;2780:52;2802:10;2814:8;2824:7;2780:21;:52::i;:::-;2593:244;2474:363;;;:::o;877:142:27:-;552:14;:12;:14::i;:::-;-1:-1:-1;;;;;538:28:27;:10;-1:-1:-1;;;;;538:28:27;;534:76;;583:20;;-1:-1:-1;;;583:20:27;;;;;;;;;;;534:76;979:35:::1;1003:2;1007:6;979:23;:35::i;5035:192:31:-:0;5117:7;5139:83;5160:4;5166:6;5174:15;5184:4;5174:9;:15::i;:::-;5191:30;5214:6;5191:22;:30::i;:::-;5139:20;:83::i;10664:226:32:-;10782:7;10848:37;10862:7;:5;:7::i;:::-;10848:6;;1864:4;10876:8;10848:13;:37::i;9166:1042::-;9354:5;-1:-1:-1;;;;;9344:15:32;:6;-1:-1:-1;;;;;9344:15:32;;9340:74;;9369:38;9385:5;9392:6;9400;9369:15;:38::i;:::-;9893:20;9899:5;9906:6;9893:5;:20::i;:::-;9923:16;9919:224;;;9949:4;-1:-1:-1;;;;;9949:13:32;;9963:7;:5;:7::i;:::-;9949:40;;-1:-1:-1;;;;;;9949:40:32;;;;;;;-1:-1:-1;;;;;25285:15:51;;;9949:40:32;;;25267:34:51;25317:18;;;25310:34;;;25380:15;;;25360:18;;;25353:43;25202:18;;9949:40:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;9919:224;;;-1:-1:-1;;;;;;;;;;;10108:9:32;;10085:51;;-1:-1:-1;;;;;10108:9:32;10119:8;10129:6;10085:22;:51::i;:::-;10002:141;9919:224;10181:5;-1:-1:-1;;;;;10154:49:32;10171:8;-1:-1:-1;;;;;10154:49:32;10163:6;-1:-1:-1;;;;;10154:49:32;;10188:6;10196;10154:49;;;;;;25581:25:51;;;25637:2;25622:18;;25615:34;25569:2;25554:18;;25407:248;10154:49:32;;;;;;;;9166:1042;;;;;;:::o;10264:128:1:-;10348:37;10357:5;10364:7;10373:5;10380:4;10348:8;:37::i;10433:227:32:-;10551:7;10618:37;1864:4;10637:7;:5;:7::i;:::-;10618:6;;:37;10646:8;10618:13;:37::i;3366:176:6:-;2316:19;:17;:19::i;:::-;-1:-1:-1;;;;;;;;;;;3484:16:6;;-1:-1:-1;;3484:16:6::1;3496:4;3484:16;::::0;;3515:20:::1;966:10:4::0;3522:12:6::1;3515:20;::::0;-1:-1:-1;;;;;2438:32:51;;;2420:51;;2408:2;2393:18;3515:20:6::1;;;;;;;3415:127;3366:176::o:0;3674:178::-;2563:16;:14;:16::i;:::-;-1:-1:-1;;;;;;;;;;;3791:17:6;;-1:-1:-1;;3791:17:6::1;::::0;;3823:22:::1;966:10:4::0;3832:12:6::1;887:96:4::0;3698:220:33;2316:19:6;:17;:19::i;:::-;3855:58:33::1;3883:10;3895:8;3905:7;3855:27;:58::i;11993:477:1:-:0;12092:24;12119:25;12129:5;12136:7;12119:9;:25::i;:::-;12092:52;;-1:-1:-1;;12158:16:1;:37;12154:310;;12234:5;12215:16;:24;12211:130;;;12293:7;12302:16;12320:5;12266:60;;-1:-1:-1;;;12266:60:1;;;;;;;;;;:::i;12211:130::-;12382:57;12391:5;12398:7;12426:5;12407:16;:24;12433:5;12382:8;:57::i;6868:300::-;-1:-1:-1;;;;;6951:18:1;;6947:86;;6992:30;;-1:-1:-1;;;6992:30:1;;7019:1;6992:30;;;2420:51:51;2393:18;;6992:30:1;2246:231:51;6947:86:1;-1:-1:-1;;;;;7046:16:1;;7042:86;;7085:32;;-1:-1:-1;;;7085:32:1;;7114:1;7085:32;;;2420:51:51;2393:18;;7085:32:1;2246:231:51;7042:86:1;7137:24;7145:4;7151:2;7155:5;7137:7;:24::i;11107:391:31:-;11172:31;11196:6;11172:23;:31::i;:::-;11168:44;;;11107:391;:::o;11168:44::-;11217:18;11238:30;11261:6;11238:22;:30::i;:::-;11336:15;:28;;:15;:28;;;;;-1:-1:-1;11336:28:31;;;;;;;;-1:-1:-1;;;;;;11336:28:31;-1:-1:-1;;;;;11336:28:31;;;;;11394:46;;;;;;;;;;;;11217:51;;-1:-1:-1;;;;;;;;;;;;1684:26:31;11336:28;11394:46;;11417:22;11217:51;11417:20;:22::i;:::-;-1:-1:-1;;;;;11394:46:31;;;;;;-1:-1:-1;;;;;11370:21:31;;;;;;:13;;;:21;;;;;;;;;:70;;;;;;;;;;;;;;;;;;;;;;;;11452:41;;;;;;11482:10;160:25:51;;148:2;133:18;;14:177;11452:41:31;;;;;;;;11162:336;;11107:391;:::o;6482:221:3:-;6574:5;;4093:22;6591:47;-1:-1:-1;13718:5:3;6655:21;;:41;;;-1:-1:-1;;;6655:21:3;;;;:41;:::i;4015:109:7:-;4068:7;4094:23;:21;:23::i;10894:107:32:-;10934:7;10956:4;-1:-1:-1;;;;;10956:31:32;;10988:7;:5;:7::i;:::-;10956:40;;-1:-1:-1;;;;;;10956:40:32;;;;;;;-1:-1:-1;;;;;2438:32:51;;;10956:40:32;;;2420:51:51;2393:18;;10956:40:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;8051:302:20:-;8152:7;8171:14;8188:25;8195:1;8198;8201:11;8188:6;:25::i;:::-;8171:42;;8227:26;8244:8;8227:16;:26::i;:::-;:59;;;;;8285:1;8270:11;8257:25;;;;;:::i;:::-;8267:1;8264;8257:25;:29;8227:59;8223:101;;;8302:11;8312:1;8302:11;;:::i;8973:189:32:-;9109:48;9118:6;9126:8;9136:6;9144;9152:4;9109:8;:48::i;2821:154:2:-;2923:7;2949:19;2962:5;2949:12;:19::i;6300:155:7:-;6441:7;6434:14;;6354:13;;-1:-1:-1;;;;;;;;;;;2839:21:7;6434:14;;;:::i;6682:161::-;6739:13;6764:23;-1:-1:-1;;;;;;;;;;;6790:19:7;2720:156;2577:147:1;6931:20:0;:18;:20::i;:::-;2679:38:1::1;2702:5;2709:7;2679:22;:38::i;1829:125:2:-:0;6931:20:0;:18;:20::i;:::-;1913:34:2::1;1937:4;1913:34;;;;;;;;;;;;;-1:-1:-1::0;;;1913:34:2::1;;::::0;:23:::1;:34::i;2002:135:31:-:0;6931:20:0;:18;:20::i;:::-;2087:45:31::1;2116:15;2087:28;:45::i;2079:209:32:-:0;6931:20:0;:18;:20::i;:::-;2164:23:32::1;2190:45;2225:9;2190:34;:45::i;:::-;2164:71;;2241:42;2266:16;2241:24;:42::i;1836:97:6:-:0;6931:20:0;:18;:20::i;:::-;1899:27:6::1;:25;:27::i;:::-;1836:97::o:0;434:287:28:-;530:11;544:21;554:10;544:9;:21::i;:::-;530:35;;586:6;580:3;:12;:27;;604:3;580:27;;;595:6;580:27;571:36;-1:-1:-1;613:43:28;-1:-1:-1;;;;;613:31:28;;645:2;571:36;613:31;:43::i;:::-;705:2;-1:-1:-1;;;;;668:48:28;693:10;-1:-1:-1;;;;;668:48:28;681:10;-1:-1:-1;;;;;668:48:28;;709:6;668:48;;;;160:25:51;;148:2;133:18;;14:177;668:48:28;;;;;;;;524:197;434:287;;;:::o;10212:217:32:-;10368:56;10378:6;10386:8;10396:5;10403:6;10411;10419:4;10368:9;:56::i;:::-;10212:217;;;;;:::o;7755:1214::-;7910:6;7920:1;7910:11;7906:70;;7938:31;;-1:-1:-1;;;7938:31:32;;;;;;;;;;;7906:70;8515:13;8511:372;;;8538:19;8560:7;:5;:7::i;:::-;8538:29;;8575:78;8609:11;8623:6;8639:4;8646:6;8575:26;:78::i;:::-;8661:51;;-1:-1:-1;;;8661:51:32;;-1:-1:-1;;;;;26239:15:51;;;8661:51:32;;;26221:34:51;26271:18;;;26264:34;;;8703:4:32;26314:18:51;;;26307:43;8710:1:32;26366:18:51;;;26359:47;8661:4:32;:12;;;;26155:19:51;;8661:51:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8530:189;8511:372;;;-1:-1:-1;;;;;;;;;;;8835:9:32;;8808:68;;-1:-1:-1;;;;;8835:9:32;8846:6;8862:4;8869:6;8808:26;:68::i;:::-;8725:158;8511:372;8888:23;8894:8;8904:6;8888:5;:23::i;:::-;8939:8;-1:-1:-1;;;;;8923:41:32;8931:6;-1:-1:-1;;;;;8923:41:32;;8949:6;8957;8923:41;;;;;;25581:25:51;;;25637:2;25622:18;;25615:34;25569:2;25554:18;;25407:248;8923:41:32;;;;;;;;7755:1214;;;;;:::o;4946:176:7:-;5023:7;5049:66;5082:20;:18;:20::i;:::-;5104:10;3555:4:19;3549:11;-1:-1:-1;;;3573:23:19;;3625:4;3616:14;;3609:39;;;;3677:4;3668:14;;3661:34;3733:4;3718:20;;;3353:401;6803:260:18;6888:7;6908:17;6927:18;6947:16;6967:25;6978:4;6984:1;6987;6990;6967:10;:25::i;:::-;6907:85;;;;;;7002:28;7014:5;7021:8;7002:11;:28::i;:::-;-1:-1:-1;7047:9:18;;6803:260;-1:-1:-1;;;;;;6803:260:18:o;725:251:28:-;843:12;;;802;843;;;;;;;;;-1:-1:-1;;;;;820:7:28;;;835:6;;820:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;801:55;;;867:7;862:55;;891:19;;-1:-1:-1;;;891:19:28;;;;;;;;;;;862:55;928:43;;160:25:51;;;-1:-1:-1;;;;;928:43:28;;;948:10;;928:43;;148:2:51;133:18;928:43:28;;;;;;;795:181;725:251;;:::o;8586:792:31:-;-1:-1:-1;;;;;8855:21:31;;8735:7;8855:21;;;:13;:21;;;;;;;;8811:65;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8811:65:31;;;;;;;;-1:-1:-1;;;;;;;;;;;1684:26:31;8882:87;;8934:28;;-1:-1:-1;;;8934:28:31;;-1:-1:-1;;;;;2438:32:51;;8934:28:31;;;2420:51:51;2393:18;;8934:28:31;2246:231:51;8882:87:31;-1:-1:-1;;;;;9023:24:31;;;8975:45;9023:24;;;:18;;;:24;;;;;;;;:32;;;;;;;;;;;;8975:80;;;;;;;;;-1:-1:-1;;;;;8975:80:31;;;;;;-1:-1:-1;;;8975:80:31;;;;;;;;;;;9122:251;;9150:7;;9167:57;:169;;9284:52;;-1:-1:-1;;;;;9167:169:31;;;;9237:17;:34;;;9167:169;-1:-1:-1;;;;;9122:251:31;9346:19;9122:18;:251::i;:::-;9074:22;:39;;;-1:-1:-1;;;;;9074:299:31;;;;;:::i;9522:206:1:-;-1:-1:-1;;;;;9592:21:1;;9588:89;;9636:30;;-1:-1:-1;;;9636:30:1;;9663:1;9636:30;;;2420:51:51;2393:18;;9636:30:1;2246:231:51;9588:89:1;9686:35;9694:7;9711:1;9715:5;9686:7;:35::i;1303:160:15:-;1412:43;;-1:-1:-1;;;;;26901:32:51;;;1412:43:15;;;26883:51:51;26950:18;;;26943:34;;;1385:71:15;;1405:5;;1427:14;;;;;26856:18:51;;1412:43:15;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1412:43:15;;;;;;;;;;;1385:19;:71::i;11224:487:1:-;-1:-1:-1;;;;;;;;;;;;;;;;11389:19:1;;11385:89;;11431:32;;-1:-1:-1;;;11431:32:1;;11460:1;11431:32;;;2420:51:51;2393:18;;11431:32:1;2246:231:51;11385:89:1;-1:-1:-1;;;;;11487:21:1;;11483:90;;11531:31;;-1:-1:-1;;;11531:31:1;;11559:1;11531:31;;;2420:51:51;2393:18;;11531:31:1;2246:231:51;11483:90:1;-1:-1:-1;;;;;11582:20:1;;;;;;;:13;;;:20;;;;;;;;:29;;;;;;;;;:37;;;11629:76;;;;11679:7;-1:-1:-1;;;;;11663:31:1;11672:5;-1:-1:-1;;;;;11663:31:1;;11688:5;11663:31;;;;160:25:51;;148:2;133:18;;14:177;2905:128:6;-1:-1:-1;;;;;;;;;;;2821:9:6;;;2966:61;;;3001:15;;-1:-1:-1;;;3001:15:6;;;;;;;;;;;3105:126;-1:-1:-1;;;;;;;;;;;2821:9:6;;;3163:62;;3199:15;;-1:-1:-1;;;3199:15:6;;;;;;;;;;;9631:1364:31;9770:9;9765:1226;9789:7;:14;9785:1;:18;9765:1226;;;9853:1;-1:-1:-1;;;;;9822:33:31;9830:7;9838:1;9830:10;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;9822:33:31;;9818:66;9867:8;9818:66;9891:27;9921:34;9944:7;9952:1;9944:10;;;;;;;;:::i;:::-;;;;;;;9921:22;:34::i;:::-;9891:64;;9963:15;9981:21;9991:10;9981:9;:21::i;:::-;9963:39;;10010:18;10031:114;10061:10;10081:7;10089:1;10081:10;;;;;;;;:::i;:::-;;;;;;;10101:7;10118:19;10031:20;:114::i;:::-;10010:135;;10153:31;10194:7;10202:1;10194:10;;;;;;;;:::i;:::-;;;;;;;;;;;10187:43;;-1:-1:-1;;;10187:43:31;;10224:4;10187:43;;;2420:51:51;-1:-1:-1;;;;;10187:28:31;;;;;;2393:18:51;;10187:43:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10153:77;;10238:23;10291;10278:10;:36;10274:132;;;10353:44;10385:7;10393:1;10385:10;;;;;;;;:::i;:::-;;;;;;;10353:23;:44::i;:::-;10326:71;;;;:::i;:::-;;;10274:132;10431:23;10418:10;:36;10414:161;;;10484:36;10497:23;10484:10;:36;:::i;:::-;10466:54;;10543:23;10530:36;;10414:161;10586:14;;10582:403;;-1:-1:-1;;;;;;;;;;;10739:27:31;:15;:25;:27::i;:::-;-1:-1:-1;;;;;10677:30:31;;;;;;:18;;;:30;;;;;10708:10;;10677:30;;;10708:7;;10716:1;;10708:10;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;10677:42:31;;;;;;;;;;;-1:-1:-1;10677:42:31;:89;;-1:-1:-1;;;;;10677:89:31;;;-1:-1:-1;;;10677:89:31;;;;;;;;;10871:31;:19;:29;:31::i;:::-;-1:-1:-1;;;;;10776:39:31;;;;;;:27;;;:39;;;;;10816:10;;10776:39;;;10816:7;;10824:1;;10816:10;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;10776:51:31;-1:-1:-1;;;;;10776:51:31;;;;;;;;;;;;:92;;;:126;;;;;-1:-1:-1;;;;;10776:126:31;;;;;-1:-1:-1;;;;;10776:126:31;;;;;;10912:64;10942:7;10950:1;10942:10;;;;;;;;:::i;:::-;;;;;;;10955:8;10965:10;10912:22;:64::i;:::-;10602:383;10582:403;9810:1181;;;;;9765:1226;9805:3;;;;:::i;:::-;;;;9765:1226;;4072:216:33;2316:19:6;:17;:19::i;:::-;4235:48:33::1;4266:4;4272:2;4276:6;4235:30;:48::i;1247:182:23:-:0;1304:7;-1:-1:-1;;;;;1327:26:23;;;1319:78;;;;-1:-1:-1;;;1319:78:23;;27190:2:51;1319:78:23;;;27172:21:51;27229:2;27209:18;;;27202:30;27268:34;27248:18;;;27241:62;-1:-1:-1;;;27319:18:51;;;27312:37;27366:19;;1319:78:23;26988:403:51;1319:78:23;-1:-1:-1;1418:5:23;1247:182::o;4130:191:7:-;4185:7;2073:95;4243:17;:15;:17::i;:::-;4262:20;:18;:20::i;:::-;4221:92;;;;;;27655:25:51;;;;27696:18;;27689:34;;;;27739:18;;;27732:34;4284:13:7;27782:18:51;;;27775:34;4307:4:7;27825:19:51;;;27818:61;27627:19;;4221:92:7;;;;;;;;;;;;4211:103;;;;;;4204:110;;4130:191;:::o;3803:4116:20:-;3885:14;4248:5;;;3885:14;-1:-1:-1;;4252:1:20;4248;4420:20;4493:5;4489:2;4486:13;4478:5;4474:2;4470:14;4466:34;4457:43;;;4595:5;4604:1;4595:10;4591:368;;4933:11;4925:5;:19;;;;;:::i;:::-;;4918:26;;;;;;4591:368;5080:5;5065:11;:20;5061:88;;5112:22;;-1:-1:-1;;;5112:22:20;;;;;;;;;;;5061:88;5404:17;5539:11;5536:1;5533;5526:25;5939:12;5969:15;;;5954:31;;6088:22;;;;;6813:1;6794;:15;;6793:21;;7046;;;7042:25;;7031:36;7115:21;;;7111:25;;7100:36;7185:21;;;7181:25;;7170:36;7255:21;;;7251:25;;7240:36;7325:21;;;7321:25;;7310:36;7396:21;;;7392:25;;;7381:36;6333:12;;;;6329:23;;;6354:1;6325:31;5653:20;;;5642:32;;;6445:12;;;;5700:21;;;;6186:16;;;;6436:21;;;;7860:15;;;;;-1:-1:-1;;3803:4116:20;;;;;:::o;14993:122::-;15061:4;15102:1;15090:8;15084:15;;;;;;;;:::i;:::-;:19;;;;:::i;:::-;:24;;15107:1;15084:24;15077:31;;14993:122;;;:::o;1259:164:5:-;1319:7;;1005:21;1364:19;886:156;7084:141:0;8870:21;8560:40;-1:-1:-1;;;8560:40:0;;;;7146:73;;7191:17;;-1:-1:-1;;;7191:17:0;;;;;;;;;;;2730:216:1;6931:20:0;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;2895:7:1;:15:::1;2905:5:::0;2895:7;:15:::1;:::i;:::-;-1:-1:-1::0;2920:9:1::1;::::0;::::1;:19;2932:7:::0;2920:9;:19:::1;:::i;3599:330:7:-:0;6931:20:0;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;3766:7:7;:14:::1;3776:4:::0;3766:7;:14:::1;:::i;:::-;-1:-1:-1::0;3790:10:7::1;::::0;::::1;:20;3803:7:::0;3790:10;:20:::1;:::i;:::-;-1:-1:-1::0;3891:1:7::1;3875:17:::0;;;3902:16:::1;::::0;;::::1;:20:::0;-1:-1:-1;;3599:330:7:o;2141:299:31:-;6931:20:0;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;2297:35:31;;-1:-1:-1;;;;;;2297:35:31::1;-1:-1:-1::0;;;;;2297:35:31;;::::1;::::0;;;::::1;::::0;;2343:21:::1;:55;::::0;2339:97:::1;;2408:21;:19;:21::i;2292:635:32:-:0;2398:6;6931:20:0;:18;:20::i;:::-;2487::32::1;2518:9;-1:-1:-1::0;;;;;2510:23:32::1;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2487:48;;2569:4;-1:-1:-1::0;;;;;2545:29:32::1;:12;-1:-1:-1::0;;;;;2545:29:32::1;;2541:75;;2583:33;::::0;-1:-1:-1;;;2583:33:32;;-1:-1:-1;;;;;2438:32:51;;2583:33:32::1;::::0;::::1;2420:51:51::0;2393:18;;2583:33:32::1;2246:231:51::0;2541:75:32::1;2623:23;2664:9;-1:-1:-1::0;;;;;2656:43:32::1;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2623:79:::0;-1:-1:-1;2709:34:32::1;-1:-1:-1::0;;;;;;;;;;;2782:29:32;;-1:-1:-1;;;;;;2782:29:32::1;-1:-1:-1::0;;;;;2782:29:32;::::1;;::::0;;;-1:-1:-1;2818:74:32::1;2841:16:::0;2867:4:::1;-1:-1:-1::0;;2818:22:32::1;:74::i;:::-;-1:-1:-1::0;2906:16:32;-1:-1:-1;;6961:1:0::1;2292:635:32::0;;;:::o;5097:304:3:-;6931:20:0;:18;:20::i;:::-;4093:22:3;5182:24:::1;::::0;5277:28:::1;5298:6:::0;5277:20:::1;:28::i;:::-;5239:66;;;;5339:7;:28;;5365:2;5339:28;;;5349:13;5339:28;5315:52:::0;;-1:-1:-1;;;;;;5377:17:3;-1:-1:-1;;;5315:52:3::1;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;;;;;5377:17:3;;-1:-1:-1;;;;;5377:17:3;;;::::1;::::0;;;::::1;::::0;;;-1:-1:-1;;5097:304:3:o;1939:156:6:-;6931:20:0;:18;:20::i;:::-;-1:-1:-1;;;;;;;;;;;2071:17:6;;-1:-1:-1;;2071:17:6::1;::::0;;1939:156::o;1405:154:24:-;1510:43;;;-1:-1:-1;;;;;26901:32:51;;1510:43:24;;;26883:51:51;26950:18;;;;26943:34;;;1510:43:24;;;;;;;;;;26856:18:51;;;;1510:43:24;;;;;;;;-1:-1:-1;;;;;1510:43:24;-1:-1:-1;;;1510:43:24;;;1483:71;;1503:5;;1483:19;:71::i;1702:188:15:-;1829:53;;-1:-1:-1;;;;;30646:15:51;;;1829:53:15;;;30628:34:51;30698:15;;;30678:18;;;30671:43;30730:18;;;30723:34;;;1802:81:15;;1822:5;;1844:18;;;;;30563::51;;1829:53:15;30388:375:51;8996:208:1;-1:-1:-1;;;;;9066:21:1;;9062:91;;9110:32;;-1:-1:-1;;;9110:32:1;;9139:1;9110:32;;;2420:51:51;2393:18;;9110:32:1;2246:231:51;9062:91:1;9162:35;9178:1;9182:7;9191:5;9162:7;:35::i;5140:1530:18:-;5266:7;;;6199:66;6186:79;;6182:164;;;-1:-1:-1;6297:1:18;;-1:-1:-1;6301:30:18;;-1:-1:-1;6333:1:18;6281:54;;6182:164;6457:24;;;6440:14;6457:24;;;;;;;;;30995:25:51;;;31068:4;31056:17;;31036:18;;;31029:45;;;;31090:18;;;31083:34;;;31133:18;;;31126:34;;;6457:24:18;;30967:19:51;;6457:24:18;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6457:24:18;;-1:-1:-1;;6457:24:18;;;-1:-1:-1;;;;;;;6495:20:18;;6491:113;;-1:-1:-1;6547:1:18;;-1:-1:-1;6551:29:18;;-1:-1:-1;6547:1:18;;-1:-1:-1;6531:62:18;;6491:113;6622:6;-1:-1:-1;6630:20:18;;-1:-1:-1;6630:20:18;;-1:-1:-1;5140:1530:18;;;;;;;;;:::o;7196:532::-;7291:20;7282:5;:29;;;;;;;;:::i;:::-;;7278:444;;7196:532;;:::o;7278:444::-;7387:29;7378:5;:38;;;;;;;;:::i;:::-;;7374:348;;7439:23;;-1:-1:-1;;;7439:23:18;;;;;;;;;;;7374:348;7492:35;7483:5;:44;;;;;;;;:::i;:::-;;7479:243;;7550:46;;-1:-1:-1;;;7550:46:18;;;;;160:25:51;;;133:18;;7550:46:18;14:177:51;7479:243:18;7626:30;7617:5;:39;;;;;;;;:::i;:::-;;7613:109;;7679:32;;-1:-1:-1;;;7679:32:18;;;;;160:25:51;;;133:18;;7679:32:18;14:177:51;7891:309:31;8043:7;8062;8073:1;8062:12;8058:41;;-1:-1:-1;8091:1:31;8084:8;;8058:41;8185:10;:8;:10::i;:::-;8179:16;;:2;:16;:::i;:::-;8123:51;8145:29;8123:19;:51;:::i;:::-;8112:63;;:7;:63;:::i;:::-;8111:84;;;;:::i;4059:629:15:-;4478:23;4504:33;-1:-1:-1;;;;;4504:27:15;;4532:4;4504:27;:33::i;:::-;4478:59;;4551:10;:17;4572:1;4551:22;;:57;;;;;4589:10;4578:30;;;;;;;;;;;;:::i;:::-;4577:31;4551:57;4547:135;;;4631:40;;-1:-1:-1;;;4631:40:15;;-1:-1:-1;;;;;2438:32:51;;4631:40:15;;;2420:51:51;2393:18;;4631:40:15;2246:231:51;8522:182:23;8579:7;-1:-1:-1;;;;;8602:26:23;;;8594:78;;;;-1:-1:-1;;;8594:78:23;;31643:2:51;8594:78:23;;;31625:21:51;31682:2;31662:18;;;31655:30;31721:34;31701:18;;;31694:62;-1:-1:-1;;;31772:18:51;;;31765:37;31819:19;;8594:78:23;31441:403:51;6092:574:31;-1:-1:-1;;;;;;;;;;;6183:28:31;6244:381;6268:15;;;:22;6264:26;;6244:381;;;6305:19;6335:1;:15;;6351:1;6335:18;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;6335:18:31;;-1:-1:-1;6385:35:31;6335:18;6385:22;:35::i;:::-;6362:58;-1:-1:-1;;;;;;6432:18:31;;;6428:87;;6462:44;6474:4;6480:12;6494:11;6462;:44::i;:::-;-1:-1:-1;;;;;6526:16:31;;;;;;:30;;;6554:2;-1:-1:-1;;;;;6546:10:31;:4;-1:-1:-1;;;;;6546:10:31;;;6526:30;6522:97;;;6568:42;6580:2;6584:12;6598:11;6568;:42::i;:::-;6297:328;;6292:3;;;;;:::i;:::-;;;;6244:381;;;;6630:31;6644:4;6650:2;6654:6;6630:13;:31::i;7058:687:7:-;7108:7;-1:-1:-1;;;;;;;;;;;7108:7:7;7203:13;:11;:13::i;:::-;7230:18;;7182:34;;-1:-1:-1;7230:22:7;7226:513;;7275:22;;;;;;;;7058:687;-1:-1:-1;;7058:687:7:o;7226:513::-;7572:13;;7603:15;;7599:130;;7645:10;7058:687;-1:-1:-1;;;7058:687:7:o;7599:130::-;7701:13;7694:20;;;;;7058:687;:::o;7966:723::-;8019:7;-1:-1:-1;;;;;;;;;;;8019:7:7;8117:16;:14;:16::i;:::-;8147:21;;8093:40;;-1:-1:-1;8147:25:7;8143:540;;8195:25;;;;;;;;7966:723;-1:-1:-1;;7966:723:7:o;8143:540::-;8507:16;;;;8541:18;;8537:136;;8586:13;7966:723;-1:-1:-1;;;7966:723:7:o;3296:380:15:-;3411:47;;;-1:-1:-1;;;;;26901:32:51;;3411:47:15;;;26883:51:51;26950:18;;;;26943:34;;;3411:47:15;;;;;;;;;;26856:18:51;;;;3411:47:15;;;;;;;;-1:-1:-1;;;;;3411:47:15;-1:-1:-1;;;3411:47:15;;;3474:44;3426:13;3411:47;3474:23;:44::i;:::-;3469:201;;3561:43;;-1:-1:-1;;;;;26901:32:51;;;3561:43:15;;;26883:51:51;3601:1:15;26950:18:51;;;26943:34;3534:71:15;;3554:5;;3576:13;;;;;26856:18:51;;3561:43:15;26709:274:51;3534:71:15;3619:40;3639:5;3646:12;3619:19;:40::i;5544:533:3:-;5721:43;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5721:43:3;-1:-1:-1;;;5721:43:3;;;5681:93;;5611:4;;;;;;;;-1:-1:-1;;;;;5681:26:3;;;:93;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5634:140;;;;5788:7;:39;;;;;5825:2;5799:15;:22;:28;;5788:39;5784:260;;;5843:24;5881:15;5870:38;;;;;;;;;;;;:::i;:::-;5843:65;-1:-1:-1;5946:15:3;5926:35;;5922:112;;5989:4;;6001:16;;-1:-1:-1;5544:533:3;-1:-1:-1;;;;5544:533:3:o;5922:112::-;5829:215;5784:260;-1:-1:-1;6061:5:3;;;;-1:-1:-1;5544:533:3;-1:-1:-1;;;5544:533:3:o;4628:597:24:-;5031:23;5057:33;-1:-1:-1;;;;;5057:27:24;;5085:4;5057:27;:33::i;2705:151:16:-;2780:12;2811:38;2833:6;2841:4;2847:1;2811:21;:38::i;6944:528:31:-;-1:-1:-1;;;;;;;;;;;7044:28:31;7123:15;7133:4;7123:9;:15::i;:::-;7105:33;-1:-1:-1;7148:11:31;;7144:210;;7226:121;:109;7256:4;7270:11;7291:7;7308:19;7226:20;:109::i;:::-;:119;:121::i;:::-;-1:-1:-1;;;;;7169:24:31;;;;;;;:18;;;:24;;;;;;;;:37;;;;;;;;;:178;;-1:-1:-1;;;;;7169:178:31;;;-1:-1:-1;;;7169:178:31;;;;;;;;;7144:210;7429:38;:19;:36;:38::i;:::-;-1:-1:-1;;;;;7359:24:31;;;;;;;:18;;;;;:24;;;;;;;;:37;;;;;;;;;;-1:-1:-1;7359:37:31;;;;:108;;-1:-1:-1;;7359:108:31;-1:-1:-1;;;;;7359:108:31;;;;;;;;;;-1:-1:-1;6944:528:31:o;7483:1170:1:-;-1:-1:-1;;;;;;;;;;;;;;;;7625:18:1;;7621:546;;7779:5;7761:1;:14;;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;7621:546:1;;-1:-1:-1;7621:546:1;;-1:-1:-1;;;;;7837:17:1;;7815:19;7837:17;;;;;;;;;;;7872:19;;;7868:115;;;7943:4;7949:11;7962:5;7918:50;;-1:-1:-1;;;7918:50:1;;;;;;;;;;:::i;7868:115::-;-1:-1:-1;;;;;8103:17:1;;:11;:17;;;;;;;;;;8123:19;;;;8103:39;;7621:546;-1:-1:-1;;;;;8181:16:1;;8177:429;;8344:14;;;:23;;;;;;;8177:429;;;-1:-1:-1;;;;;8557:15:1;;:11;:15;;;;;;;;;;:24;;;;;;8177:429;8636:2;-1:-1:-1;;;;;8621:25:1;8630:4;-1:-1:-1;;;;;8621:25:1;;8640:5;8621:25;;;;160::51;;148:2;133:18;;14:177;8621:25:1;;;;;;;;7558:1095;7483:1170;;;:::o;5189:578:15:-;5272:4;5574:12;5588:23;5623:5;-1:-1:-1;;;;;5615:19:15;5635:4;5615:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5573:67;;;;5657:7;:69;;;;-1:-1:-1;5669:17:15;;:22;;:56;;;5706:10;5695:30;;;;;;;;;;;;:::i;:::-;5657:103;;;;-1:-1:-1;;;;;;;;;;5730:26:15;;:30;;;5189:578::o;3426:179:22:-;3501:12;3528:72;3550:6;3558:4;3564:1;3528:72;;;;;;;;;;;;;;;;;:21;:72::i;3180:392:16:-;3279:12;3331:5;3307:21;:29;3303:108;;;3359:41;;-1:-1:-1;;;3359:41:16;;3394:4;3359:41;;;2420:51:51;2393:18;;3359:41:16;2246:231:51;3303:108:16;3421:12;3435:23;3462:6;-1:-1:-1;;;;;3462:11:16;3481:5;3488:4;3462:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3420:73;;;;3510:55;3537:6;3545:7;3554:10;3510:26;:55::i;4822:414:22:-;4969:12;5022:5;4997:21;:30;;4989:81;;;;-1:-1:-1;;;4989:81:22;;32338:2:51;4989:81:22;;;32320:21:51;32377:2;32357:18;;;32350:30;32416:34;32396:18;;;32389:62;-1:-1:-1;;;32467:18:51;;;32460:36;32513:19;;4989:81:22;32136:402:51;4989:81:22;5077:12;5091:23;5118:6;-1:-1:-1;;;;;5118:11:22;5137:5;5144:4;5118:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5076:73;;;;5162:69;5189:6;5197:7;5206:10;5218:12;5162:26;:69::i;:::-;5155:76;4822:414;-1:-1:-1;;;;;;;4822:414:22:o;4625:582:16:-;4769:12;4798:7;4793:408;;4821:19;4829:10;4821:7;:19::i;:::-;4793:408;;;5045:17;;:22;:49;;;;-1:-1:-1;;;;;;5071:18:16;;;:23;5045:49;5041:119;;;5121:24;;-1:-1:-1;;;5121:24:16;;-1:-1:-1;;;;;2438:32:51;;5121:24:16;;;2420:51:51;2393:18;;5121:24:16;2246:231:51;5041:119:16;-1:-1:-1;5180:10:16;5173:17;;7178:548:22;7340:12;7364:7;7360:362;;;7385:10;:17;7406:1;7385:22;7381:256;;-1:-1:-1;;;;;1513:19:22;;;7568:60;;;;-1:-1:-1;;;7568:60:22;;32745:2:51;7568:60:22;;;32727:21:51;32784:2;32764:18;;;32757:30;32823:31;32803:18;;;32796:59;32872:18;;7568:60:22;32543:353:51;7568:60:22;-1:-1:-1;7651:10:22;7644:17;;7360:362;7682:33;7690:10;7702:12;7682:7;:33::i;5743:516:16:-;5874:17;;:21;5870:383;;6102:10;6096:17;6158:15;6145:10;6141:2;6137:19;6130:44;5870:383;6225:17;;-1:-1:-1;;;6225:17:16;;;;;;;;;;;8192:476:22;8343:17;;:21;8339:325;;8545:10;8539:17;8593:15;8580:10;8576:2;8572:19;8565:44;8339:325;8644:12;8637:20;;-1:-1:-1;;;8637:20:22;;;;;;;;:::i;196:250:51:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:51;420:16;;413:27;196:250::o;451:271::-;493:3;531:5;525:12;558:6;553:3;546:19;574:76;643:6;636:4;631:3;627:14;620:4;613:5;609:16;574:76;:::i;:::-;704:2;683:15;-1:-1:-1;;679:29:51;670:39;;;;711:4;666:50;;451:271;-1:-1:-1;;451:271:51:o;727:220::-;876:2;865:9;858:21;839:4;896:45;937:2;926:9;922:18;914:6;896:45;:::i;952:180::-;1011:6;1064:2;1052:9;1043:7;1039:23;1035:32;1032:52;;;1080:1;1077;1070:12;1032:52;-1:-1:-1;1103:23:51;;952:180;-1:-1:-1;952:180:51:o;1137:131::-;-1:-1:-1;;;;;1212:31:51;;1202:42;;1192:70;;1258:1;1255;1248:12;1273:456;1350:6;1358;1366;1419:2;1407:9;1398:7;1394:23;1390:32;1387:52;;;1435:1;1432;1425:12;1387:52;1471:9;1458:23;1448:33;;1531:2;1520:9;1516:18;1503:32;1544:31;1569:5;1544:31;:::i;:::-;1594:5;-1:-1:-1;1651:2:51;1636:18;;1623:32;1664:33;1623:32;1664:33;:::i;:::-;1716:7;1706:17;;;1273:456;;;;;:::o;1734:315::-;1802:6;1810;1863:2;1851:9;1842:7;1838:23;1834:32;1831:52;;;1879:1;1876;1869:12;1831:52;1918:9;1905:23;1937:31;1962:5;1937:31;:::i;:::-;1987:5;2039:2;2024:18;;;;2011:32;;-1:-1:-1;;;1734:315:51:o;2482:118::-;2568:5;2561:13;2554:21;2547:5;2544:32;2534:60;;2590:1;2587;2580:12;2605:241;2661:6;2714:2;2702:9;2693:7;2689:23;2685:32;2682:52;;;2730:1;2727;2720:12;2682:52;2769:9;2756:23;2788:28;2810:5;2788:28;:::i;2851:127::-;2912:10;2907:3;2903:20;2900:1;2893:31;2943:4;2940:1;2933:15;2967:4;2964:1;2957:15;2983:252;3055:2;3049:9;3097:3;3085:16;;-1:-1:-1;;;;;3116:34:51;;3152:22;;;3113:62;3110:88;;;3178:18;;:::i;:::-;3214:2;3207:22;2983:252;:::o;3240:275::-;3311:2;3305:9;3376:2;3357:13;;-1:-1:-1;;3353:27:51;3341:40;;-1:-1:-1;;;;;3396:34:51;;3432:22;;;3393:62;3390:88;;;3458:18;;:::i;:::-;3494:2;3487:22;3240:275;;-1:-1:-1;3240:275:51:o;3520:183::-;3580:4;-1:-1:-1;;;;;3605:6:51;3602:30;3599:56;;;3635:18;;:::i;:::-;-1:-1:-1;3680:1:51;3676:14;3692:4;3672:25;;3520:183::o;3708:737::-;3762:5;3815:3;3808:4;3800:6;3796:17;3792:27;3782:55;;3833:1;3830;3823:12;3782:55;3869:6;3856:20;3895:4;3919:60;3935:43;3975:2;3935:43;:::i;:::-;3919:60;:::i;:::-;4013:15;;;4099:1;4095:10;;;;4083:23;;4079:32;;;4044:12;;;;4123:15;;;4120:35;;;4151:1;4148;4141:12;4120:35;4187:2;4179:6;4175:15;4199:217;4215:6;4210:3;4207:15;4199:217;;;4295:3;4282:17;4312:31;4337:5;4312:31;:::i;:::-;4356:18;;4394:12;;;;4232;;4199:217;;;-1:-1:-1;4434:5:51;3708:737;-1:-1:-1;;;;;;3708:737:51:o;4450:483::-;4543:6;4551;4604:2;4592:9;4583:7;4579:23;4575:32;4572:52;;;4620:1;4617;4610:12;4572:52;4659:9;4646:23;4678:31;4703:5;4678:31;:::i;:::-;4728:5;-1:-1:-1;4784:2:51;4769:18;;4756:32;-1:-1:-1;;;;;4800:30:51;;4797:50;;;4843:1;4840;4833:12;4797:50;4866:61;4919:7;4910:6;4899:9;4895:22;4866:61;:::i;:::-;4856:71;;;4450:483;;;;;:::o;4938:456::-;5015:6;5023;5031;5084:2;5072:9;5063:7;5059:23;5055:32;5052:52;;;5100:1;5097;5090:12;5052:52;5139:9;5126:23;5158:31;5183:5;5158:31;:::i;:::-;5208:5;-1:-1:-1;5265:2:51;5250:18;;5237:32;5278:33;5237:32;5278:33;:::i;:::-;4938:456;;5330:7;;-1:-1:-1;;;5384:2:51;5369:18;;;;5356:32;;4938:456::o;6218:247::-;6277:6;6330:2;6318:9;6309:7;6305:23;6301:32;6298:52;;;6346:1;6343;6336:12;6298:52;6385:9;6372:23;6404:31;6429:5;6404:31;:::i;6650:315::-;6718:6;6726;6779:2;6767:9;6758:7;6754:23;6750:32;6747:52;;;6795:1;6792;6785:12;6747:52;6831:9;6818:23;6808:33;;6891:2;6880:9;6876:18;6863:32;6904:31;6929:5;6904:31;:::i;:::-;6954:5;6944:15;;;6650:315;;;;;:::o;7193:1259::-;7599:3;7594;7590:13;7582:6;7578:26;7567:9;7560:45;7541:4;7624:2;7662:3;7657:2;7646:9;7642:18;7635:31;7689:46;7730:3;7719:9;7715:19;7707:6;7689:46;:::i;:::-;7783:9;7775:6;7771:22;7766:2;7755:9;7751:18;7744:50;7817:33;7843:6;7835;7817:33;:::i;:::-;7881:2;7866:18;;7859:34;;;-1:-1:-1;;;;;7930:32:51;;7924:3;7909:19;;7902:61;7950:3;7979:19;;7972:35;;;8044:22;;;8038:3;8023:19;;8016:51;8116:13;;8138:22;;;8214:15;;;;-1:-1:-1;8176:15:51;;;;-1:-1:-1;8257:169:51;8271:6;8268:1;8265:13;8257:169;;;8332:13;;8320:26;;8401:15;;;;8366:12;;;;8293:1;8286:9;8257:169;;;-1:-1:-1;8443:3:51;;7193:1259;-1:-1:-1;;;;;;;;;;;;7193:1259:51:o;8457:388::-;8525:6;8533;8586:2;8574:9;8565:7;8561:23;8557:32;8554:52;;;8602:1;8599;8592:12;8554:52;8641:9;8628:23;8660:31;8685:5;8660:31;:::i;:::-;8710:5;-1:-1:-1;8767:2:51;8752:18;;8739:32;8780:33;8739:32;8780:33;:::i;8850:348::-;8934:6;8987:2;8975:9;8966:7;8962:23;8958:32;8955:52;;;9003:1;9000;8993:12;8955:52;9043:9;9030:23;-1:-1:-1;;;;;9068:6:51;9065:30;9062:50;;;9108:1;9105;9098:12;9062:50;9131:61;9184:7;9175:6;9164:9;9160:22;9131:61;:::i;9203:348::-;9255:8;9265:6;9319:3;9312:4;9304:6;9300:17;9296:27;9286:55;;9337:1;9334;9327:12;9286:55;-1:-1:-1;9360:20:51;;-1:-1:-1;;;;;9392:30:51;;9389:50;;;9435:1;9432;9425:12;9389:50;9472:4;9464:6;9460:17;9448:29;;9524:3;9517:4;9508:6;9500;9496:19;9492:30;9489:39;9486:59;;;9541:1;9538;9531:12;9486:59;9203:348;;;;;:::o;9556:856::-;9657:6;9665;9673;9681;9689;9742:2;9730:9;9721:7;9717:23;9713:32;9710:52;;;9758:1;9755;9748:12;9710:52;9797:9;9784:23;9816:31;9841:5;9816:31;:::i;:::-;9866:5;-1:-1:-1;9922:2:51;9907:18;;9894:32;-1:-1:-1;;;;;9975:14:51;;;9972:34;;;10002:1;9999;9992:12;9972:34;10041:59;10092:7;10083:6;10072:9;10068:22;10041:59;:::i;:::-;10119:8;;-1:-1:-1;10015:85:51;-1:-1:-1;10207:2:51;10192:18;;10179:32;;-1:-1:-1;10223:16:51;;;10220:36;;;10252:1;10249;10242:12;10220:36;;10291:61;10344:7;10333:8;10322:9;10318:24;10291:61;:::i;:::-;9556:856;;;;-1:-1:-1;9556:856:51;;-1:-1:-1;10371:8:51;;10265:87;9556:856;-1:-1:-1;;;9556:856:51:o;10417:461::-;10470:3;10508:5;10502:12;10535:6;10530:3;10523:19;10561:4;10590:2;10585:3;10581:12;10574:19;;10627:2;10620:5;10616:14;10648:1;10658:195;10672:6;10669:1;10666:13;10658:195;;;10737:13;;-1:-1:-1;;;;;10733:39:51;10721:52;;10793:12;;;;10828:15;;;;10769:1;10687:9;10658:195;;;-1:-1:-1;10869:3:51;;10417:461;-1:-1:-1;;;;;10417:461:51:o;10883:261::-;11062:2;11051:9;11044:21;11025:4;11082:56;11134:2;11123:9;11119:18;11111:6;11082:56;:::i;11149:156::-;11215:20;;11275:4;11264:16;;11254:27;;11244:55;;11295:1;11292;11285:12;11310:1068;11436:6;11444;11452;11460;11468;11512:9;11503:7;11499:23;11542:3;11538:2;11534:12;11531:32;;;11559:1;11556;11549:12;11531:32;11595:9;11582:23;11572:33;;11655:2;11644:9;11640:18;11627:32;11668:31;11693:5;11668:31;:::i;:::-;11718:5;-1:-1:-1;11770:2:51;11755:18;;11742:32;;-1:-1:-1;11808:2:51;-1:-1:-1;;11790:16:51;;11786:25;11783:45;;;11824:1;11821;11814:12;11783:45;;11857:2;11851:9;11899:2;11891:6;11887:15;11968:6;11956:10;11953:22;-1:-1:-1;;;;;11920:10:51;11917:34;11914:62;11911:88;;;11979:18;;:::i;:::-;12015:2;12008:22;12054:36;12086:2;12071:18;;12054:36;:::i;:::-;12039:52;;12152:3;12137:19;;12124:33;12119:2;12107:15;;12100:58;12219:3;12204:19;;12191:33;12186:2;12174:15;;12167:58;12046:6;-1:-1:-1;12302:3:51;12287:19;;12274:33;12316:30;12274:33;12316:30;:::i;:::-;12365:7;12355:17;;;11310:1068;;;;;;;;:::o;12383:734::-;12494:6;12502;12510;12518;12526;12534;12542;12595:3;12583:9;12574:7;12570:23;12566:33;12563:53;;;12612:1;12609;12602:12;12563:53;12651:9;12638:23;12670:31;12695:5;12670:31;:::i;:::-;12720:5;-1:-1:-1;12777:2:51;12762:18;;12749:32;12790:33;12749:32;12790:33;:::i;:::-;12842:7;-1:-1:-1;12896:2:51;12881:18;;12868:32;;-1:-1:-1;12947:2:51;12932:18;;12919:32;;-1:-1:-1;12970:37:51;13002:3;12987:19;;12970:37;:::i;:::-;12960:47;;13054:3;13043:9;13039:19;13026:33;13016:43;;13106:3;13095:9;13091:19;13078:33;13068:43;;12383:734;;;;;;;;;;:::o;13122:624::-;13224:6;13232;13240;13293:2;13281:9;13272:7;13268:23;13264:32;13261:52;;;13309:1;13306;13299:12;13261:52;13348:9;13335:23;13367:31;13392:5;13367:31;:::i;:::-;13417:5;-1:-1:-1;13474:2:51;13459:18;;13446:32;13487:33;13446:32;13487:33;:::i;:::-;13539:7;-1:-1:-1;13597:2:51;13582:18;;13569:32;-1:-1:-1;;;;;13613:30:51;;13610:50;;;13656:1;13653;13646:12;13610:50;13679:61;13732:7;13723:6;13712:9;13708:22;13679:61;:::i;:::-;13669:71;;;13122:624;;;;;:::o;13751:380::-;13830:1;13826:12;;;;13873;;;13894:61;;13948:4;13940:6;13936:17;13926:27;;13894:61;14001:2;13993:6;13990:14;13970:18;13967:38;13964:161;;14047:10;14042:3;14038:20;14035:1;14028:31;14082:4;14079:1;14072:15;14110:4;14107:1;14100:15;13964:161;;13751:380;;;:::o;14136:138::-;14215:13;;14237:31;14215:13;14237:31;:::i;14279:956::-;14374:6;14405:2;14448;14436:9;14427:7;14423:23;14419:32;14416:52;;;14464:1;14461;14454:12;14416:52;14497:9;14491:16;-1:-1:-1;;;;;14522:6:51;14519:30;14516:50;;;14562:1;14559;14552:12;14516:50;14585:22;;14638:4;14630:13;;14626:27;-1:-1:-1;14616:55:51;;14667:1;14664;14657:12;14616:55;14696:2;14690:9;14719:60;14735:43;14775:2;14735:43;:::i;14719:60::-;14813:15;;;14895:1;14891:10;;;;14883:19;;14879:28;;;14844:12;;;;14919:19;;;14916:39;;;14951:1;14948;14941:12;14916:39;14975:11;;;;14995:210;15011:6;15006:3;15003:15;14995:210;;;15084:3;15078:10;15101:31;15126:5;15101:31;:::i;:::-;15145:18;;15028:12;;;;15183;;;;14995:210;;15240:127;15301:10;15296:3;15292:20;15289:1;15282:31;15332:4;15329:1;15322:15;15356:4;15353:1;15346:15;15372:127;15433:10;15428:3;15424:20;15421:1;15414:31;15464:4;15461:1;15454:15;15488:4;15485:1;15478:15;15504:135;15543:3;15564:17;;;15561:43;;15584:18;;:::i;:::-;-1:-1:-1;15631:1:51;15620:13;;15504:135::o;15644:426::-;15725:5;15773:4;15761:9;15756:3;15752:19;15748:30;15745:50;;;15791:1;15788;15781:12;15745:50;15824:2;15818:9;15866:4;15858:6;15854:17;15937:6;15925:10;15922:22;-1:-1:-1;;;;;15889:10:51;15886:34;15883:62;15880:88;;;15948:18;;:::i;:::-;15984:2;15977:22;16047:16;;16032:32;;-1:-1:-1;16017:6:51;15644:426;-1:-1:-1;15644:426:51:o;16075:192::-;16154:13;;-1:-1:-1;;;;;16196:46:51;;16186:57;;16176:85;;16257:1;16254;16247:12;16272:169;16350:13;;16403:12;16392:24;;16382:35;;16372:63;;16431:1;16428;16421:12;16446:163;16524:13;;16577:6;16566:18;;16556:29;;16546:57;;16599:1;16596;16589:12;16614:1658;16720:6;16773:3;16761:9;16752:7;16748:23;16744:33;16741:53;;;16790:1;16787;16780:12;16741:53;16816:22;;:::i;:::-;16861:72;16925:7;16914:9;16861:72;:::i;:::-;16854:5;16847:87;16966:49;17011:2;17000:9;16996:18;16966:49;:::i;:::-;16961:2;16954:5;16950:14;16943:73;17048:49;17093:2;17082:9;17078:18;17048:49;:::i;:::-;17043:2;17036:5;17032:14;17025:73;17130:49;17175:2;17164:9;17160:18;17130:49;:::i;:::-;17125:2;17118:5;17114:14;17107:73;17213:50;17258:3;17247:9;17243:19;17213:50;:::i;:::-;17207:3;17200:5;17196:15;17189:75;17297:50;17342:3;17331:9;17327:19;17297:50;:::i;:::-;17291:3;17284:5;17280:15;17273:75;17381:49;17425:3;17414:9;17410:19;17381:49;:::i;:::-;17375:3;17368:5;17364:15;17357:74;17464:49;17508:3;17497:9;17493:19;17464:49;:::i;:::-;17458:3;17451:5;17447:15;17440:74;17533:3;17568:49;17613:2;17602:9;17598:18;17568:49;:::i;:::-;17552:14;;;17545:73;17637:3;17672:49;17702:18;;;17672:49;:::i;:::-;17656:14;;;17649:73;17741:3;17776:49;17806:18;;;17776:49;:::i;:::-;17760:14;;;17753:73;17845:3;17880:49;17910:18;;;17880:49;:::i;:::-;17864:14;;;17857:73;17949:3;17984:49;18014:18;;;17984:49;:::i;:::-;17968:14;;;17961:73;18053:3;18088:49;18118:18;;;18088:49;:::i;:::-;18072:14;;;18065:73;18157:3;18192:49;18222:18;;;18192:49;:::i;:::-;18176:14;;;18169:73;18180:5;16614:1658;-1:-1:-1;;;16614:1658:51:o;18277:422::-;18366:1;18409:5;18366:1;18423:270;18444:7;18434:8;18431:21;18423:270;;;18503:4;18499:1;18495:6;18491:17;18485:4;18482:27;18479:53;;;18512:18;;:::i;:::-;18562:7;18552:8;18548:22;18545:55;;;18582:16;;;;18545:55;18661:22;;;;18621:15;;;;18423:270;;;18427:3;18277:422;;;;;:::o;18704:806::-;18753:5;18783:8;18773:80;;-1:-1:-1;18824:1:51;18838:5;;18773:80;18872:4;18862:76;;-1:-1:-1;18909:1:51;18923:5;;18862:76;18954:4;18972:1;18967:59;;;;19040:1;19035:130;;;;18947:218;;18967:59;18997:1;18988:10;;19011:5;;;19035:130;19072:3;19062:8;19059:17;19056:43;;;19079:18;;:::i;:::-;-1:-1:-1;;19135:1:51;19121:16;;19150:5;;18947:218;;19249:2;19239:8;19236:16;19230:3;19224:4;19221:13;19217:36;19211:2;19201:8;19198:16;19193:2;19187:4;19184:12;19180:35;19177:77;19174:159;;;-1:-1:-1;19286:19:51;;;19318:5;;19174:159;19365:34;19390:8;19384:4;19365:34;:::i;:::-;19435:6;19431:1;19427:6;19423:19;19414:7;19411:32;19408:58;;;19446:18;;:::i;:::-;19484:20;;18704:806;-1:-1:-1;;;18704:806:51:o;19515:131::-;19575:5;19604:36;19631:8;19625:4;19604:36;:::i;19651:168::-;19724:9;;;19755;;19772:15;;;19766:22;;19752:37;19742:71;;19793:18;;:::i;19824:184::-;19894:6;19947:2;19935:9;19926:7;19922:23;19918:32;19915:52;;;19963:1;19960;19953:12;19915:52;-1:-1:-1;19986:16:51;;19824:184;-1:-1:-1;19824:184:51:o;20013:125::-;20078:9;;;20099:10;;;20096:36;;;20112:18;;:::i;20143:128::-;20210:9;;;20231:11;;;20228:37;;;20245:18;;:::i;20276:251::-;20346:6;20399:2;20387:9;20378:7;20374:23;20370:32;20367:52;;;20415:1;20412;20405:12;20367:52;20447:9;20441:16;20466:31;20491:5;20466:31;:::i;20532:459::-;20767:2;20756:9;20749:21;20730:4;20787:56;20839:2;20828:9;20824:18;20816:6;20787:56;:::i;:::-;-1:-1:-1;;;;;20917:15:51;;;20912:2;20897:18;;20890:43;20969:15;;;;20964:2;20949:18;;;20942:43;20779:64;20532:459;-1:-1:-1;;20532:459:51:o;20996:345::-;-1:-1:-1;;;;;21216:32:51;;;;21198:51;;21280:2;21265:18;;21258:34;;;;21323:2;21308:18;;21301:34;21186:2;21171:18;;20996:345::o;21346:245::-;21413:6;21466:2;21454:9;21445:7;21441:23;21437:32;21434:52;;;21482:1;21479;21472:12;21434:52;21514:9;21508:16;21533:28;21555:5;21533:28;:::i;22160:532::-;22423:3;22412:9;22405:22;22386:4;22444:57;22496:3;22485:9;22481:19;22473:6;22444:57;:::i;:::-;22532:2;22517:18;;22510:34;;;;-1:-1:-1;;;;;;22618:15:51;;;22613:2;22598:18;;22591:43;22670:15;;22665:2;22650:18;;;22643:43;22436:65;22160:532;-1:-1:-1;22160:532:51:o;24277:282::-;24389:6;24442:2;24430:9;24421:7;24417:23;24413:32;24410:52;;;24458:1;24455;24448:12;24410:52;24481:72;24545:7;24534:9;24481:72;:::i;24564:208::-;24634:6;24687:2;24675:9;24666:7;24662:23;24658:32;24655:52;;;24703:1;24700;24693:12;24655:52;24726:40;24756:9;24726:40;:::i;24777:245::-;24856:6;24864;24917:2;24905:9;24896:7;24892:23;24888:32;24885:52;;;24933:1;24930;24923:12;24885:52;-1:-1:-1;;24956:16:51;;25012:2;24997:18;;;24991:25;24956:16;;24991:25;;-1:-1:-1;24777:245:51:o;25660:148::-;25748:4;25727:12;;;25741;;;25723:31;;25766:13;;25763:39;;;25782:18;;:::i;25813:127::-;25874:10;25869:3;25865:20;25862:1;25855:31;25905:4;25902:1;25895:15;25929:4;25926:1;25919:15;26417:287;26546:3;26584:6;26578:13;26600:66;26659:6;26654:3;26647:4;26639:6;26635:17;26600:66;:::i;:::-;26682:16;;;;;26417:287;-1:-1:-1;;26417:287:51:o;27890:127::-;27951:10;27946:3;27942:20;27939:1;27932:31;27982:4;27979:1;27972:15;28006:4;28003:1;27996:15;28022:157;28052:1;28086:4;28083:1;28079:12;28110:3;28100:37;;28117:18;;:::i;:::-;28169:3;28162:4;28159:1;28155:12;28151:22;28146:27;;;28022:157;;;;:::o;28310:545::-;28412:2;28407:3;28404:11;28401:448;;;28448:1;28473:5;28469:2;28462:17;28518:4;28514:2;28504:19;28588:2;28576:10;28572:19;28569:1;28565:27;28559:4;28555:38;28624:4;28612:10;28609:20;28606:47;;;-1:-1:-1;28647:4:51;28606:47;28702:2;28697:3;28693:12;28690:1;28686:20;28680:4;28676:31;28666:41;;28757:82;28775:2;28768:5;28765:13;28757:82;;;28820:17;;;28801:1;28790:13;28757:82;;;28761:3;;;28310:545;;;:::o;29031:1352::-;29157:3;29151:10;-1:-1:-1;;;;;29176:6:51;29173:30;29170:56;;;29206:18;;:::i;:::-;29235:97;29325:6;29285:38;29317:4;29311:11;29285:38;:::i;:::-;29279:4;29235:97;:::i;:::-;29387:4;;29451:2;29440:14;;29468:1;29463:663;;;;30170:1;30187:6;30184:89;;;-1:-1:-1;30239:19:51;;;30233:26;30184:89;-1:-1:-1;;28988:1:51;28984:11;;;28980:24;28976:29;28966:40;29012:1;29008:11;;;28963:57;30286:81;;29433:944;;29463:663;28257:1;28250:14;;;28294:4;28281:18;;-1:-1:-1;;29499:20:51;;;29617:236;29631:7;29628:1;29625:14;29617:236;;;29720:19;;;29714:26;29699:42;;29812:27;;;;29780:1;29768:14;;;;29647:19;;29617:236;;;29621:3;29881:6;29872:7;29869:19;29866:201;;;29942:19;;;29936:26;-1:-1:-1;;30025:1:51;30021:14;;;30037:3;30017:24;30013:37;30009:42;29994:58;29979:74;;29866:201;-1:-1:-1;;;;;30113:1:51;30097:14;;;30093:22;30080:36;;-1:-1:-1;29031:1352:51:o;31171:140::-;31229:5;31258:47;31299:4;31289:8;31285:19;31279:4;31258:47;:::i;31316:120::-;31356:1;31382;31372:35;;31387:18;;:::i;:::-;-1:-1:-1;31421:9:51;;31316:120::o

none