ETH Price: $3,670.53 (-3.73%)

Transaction Decoder

Block:
19093914 at Jan-26-2024 11:01:11 PM +UTC
Transaction Fee:
0.001584016351019781 ETH $5.81
Gas Used:
127,343 Gas / 12.438974667 Gwei

Emitted Events:

311 ERC1967Proxy.0xa512c82e73ec974de3c794a3ea6bbdfbad18531c1394ace9972f3f0166b67863( 0xa512c82e73ec974de3c794a3ea6bbdfbad18531c1394ace9972f3f0166b67863, 0x000000000000000000000000f32e58f92e60f4b0a37a69b95d642a471365eae8, 000000000000000000000000000000000000000000c2404aeda10c7b60545780, 00000000000000000000000000000000000000000000000001db2437cbd94d18 )
312 ERC1967Proxy.0xc71e393f1527f71ce01b78ea87c9bd4fca84f1482359ce7ac9b73f358c61b1e1( 0xc71e393f1527f71ce01b78ea87c9bd4fca84f1482359ce7ac9b73f358c61b1e1, 0x000000000000000000000000f018cd5eb7b4a9668aeb17e53120f703a84345d2, 0x000000000000000000000000f32e58f92e60f4b0a37a69b95d642a471365eae8, 0000000000000000000000000000000000000000000000000de0b6b3a7640000, 000000000000000000000000000000000000000000000577a375b5a18c038300, 00000000000000000000000000000000000000000000000000000d826a6e4343 )

Account State Difference:

  Address   Before After State Difference Code
0x44087E10...82821F2F0
(Titan Builder)
14.256885031476636921 Eth14.256891398626636921 Eth0.00000636715
0xF018cd5E...3a84345d2
0.096172417544148532 Eth
Nonce: 243
0.094588401193128751 Eth
Nonce: 244
0.001584016351019781

Execution Trace

ERC1967Proxy.698766ee( )
  • PendleVotingControllerUpg.vote( pools=[0xF32e58F92e60f4b0A37A69b95d642A471365EAe8], weights=[1000000000000000000] )
    • VotingEscrowPendleMainchain.balanceOf( user=0xF018cd5EB7b4a9668aEb17E53120F703a84345d2 ) => ( 473614771808647217947 )
    • VotingEscrowPendleMainchain.positionData( 0xF018cd5EB7b4a9668aEb17E53120F703a84345d2 ) => ( amount=934291037522477200000, expiry=1738195200 )
      File 1 of 3: ERC1967Proxy
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
       * proxy whose upgrades are fully controlled by the current implementation.
       */
      interface IERC1822Proxiable {
          /**
           * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
           * address.
           *
           * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
           * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
           * function revert if invoked through a proxy.
           */
          function proxiableUUID() external view returns (bytes32);
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev This is the interface that {BeaconProxy} expects of its beacon.
       */
      interface IBeacon {
          /**
           * @dev Must return an address that can be used as a delegate call target.
           *
           * {BeaconProxy} will check that this address is a contract.
           */
          function implementation() external view returns (address);
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
      pragma solidity ^0.8.0;
      import "../Proxy.sol";
      import "./ERC1967Upgrade.sol";
      /**
       * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
       * implementation address that can be changed. This address is stored in storage in the location specified by
       * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
       * implementation behind the proxy.
       */
      contract ERC1967Proxy is Proxy, ERC1967Upgrade {
          /**
           * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
           *
           * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
           * function call, and allows initializing the storage of the proxy like a Solidity constructor.
           */
          constructor(address _logic, bytes memory _data) payable {
              _upgradeToAndCall(_logic, _data, false);
          }
          /**
           * @dev Returns the current implementation address.
           */
          function _implementation() internal view virtual override returns (address impl) {
              return ERC1967Upgrade._getImplementation();
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
      pragma solidity ^0.8.2;
      import "../beacon/IBeacon.sol";
      import "../../interfaces/draft-IERC1822.sol";
      import "../../utils/Address.sol";
      import "../../utils/StorageSlot.sol";
      /**
       * @dev This abstract contract provides getters and event emitting update functions for
       * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
       *
       * _Available since v4.1._
       *
       * @custom:oz-upgrades-unsafe-allow delegatecall
       */
      abstract contract ERC1967Upgrade {
          // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
          bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
          /**
           * @dev Storage slot with the address of the current implementation.
           * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
           * validated in the constructor.
           */
          bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
          /**
           * @dev Emitted when the implementation is upgraded.
           */
          event Upgraded(address indexed implementation);
          /**
           * @dev Returns the current implementation address.
           */
          function _getImplementation() internal view returns (address) {
              return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
          }
          /**
           * @dev Stores a new address in the EIP1967 implementation slot.
           */
          function _setImplementation(address newImplementation) private {
              require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
              StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
          }
          /**
           * @dev Perform implementation upgrade
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeTo(address newImplementation) internal {
              _setImplementation(newImplementation);
              emit Upgraded(newImplementation);
          }
          /**
           * @dev Perform implementation upgrade with additional setup call.
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeToAndCall(
              address newImplementation,
              bytes memory data,
              bool forceCall
          ) internal {
              _upgradeTo(newImplementation);
              if (data.length > 0 || forceCall) {
                  Address.functionDelegateCall(newImplementation, data);
              }
          }
          /**
           * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeToAndCallUUPS(
              address newImplementation,
              bytes memory data,
              bool forceCall
          ) internal {
              // Upgrades from old implementations will perform a rollback test. This test requires the new
              // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
              // this special case will break upgrade paths from old UUPS implementation to new ones.
              if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                  _setImplementation(newImplementation);
              } else {
                  try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                      require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                  } catch {
                      revert("ERC1967Upgrade: new implementation is not UUPS");
                  }
                  _upgradeToAndCall(newImplementation, data, forceCall);
              }
          }
          /**
           * @dev Storage slot with the admin of the contract.
           * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
           * validated in the constructor.
           */
          bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
          /**
           * @dev Emitted when the admin account has changed.
           */
          event AdminChanged(address previousAdmin, address newAdmin);
          /**
           * @dev Returns the current admin.
           */
          function _getAdmin() internal view returns (address) {
              return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
          }
          /**
           * @dev Stores a new address in the EIP1967 admin slot.
           */
          function _setAdmin(address newAdmin) private {
              require(newAdmin != address(0), "ERC1967: new admin is the zero address");
              StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
          }
          /**
           * @dev Changes the admin of the proxy.
           *
           * Emits an {AdminChanged} event.
           */
          function _changeAdmin(address newAdmin) internal {
              emit AdminChanged(_getAdmin(), newAdmin);
              _setAdmin(newAdmin);
          }
          /**
           * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
           * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
           */
          bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
          /**
           * @dev Emitted when the beacon is upgraded.
           */
          event BeaconUpgraded(address indexed beacon);
          /**
           * @dev Returns the current beacon.
           */
          function _getBeacon() internal view returns (address) {
              return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
          }
          /**
           * @dev Stores a new beacon in the EIP1967 beacon slot.
           */
          function _setBeacon(address newBeacon) private {
              require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
              require(
                  Address.isContract(IBeacon(newBeacon).implementation()),
                  "ERC1967: beacon implementation is not a contract"
              );
              StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
          }
          /**
           * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
           * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
           *
           * Emits a {BeaconUpgraded} event.
           */
          function _upgradeBeaconToAndCall(
              address newBeacon,
              bytes memory data,
              bool forceCall
          ) internal {
              _setBeacon(newBeacon);
              emit BeaconUpgraded(newBeacon);
              if (data.length > 0 || forceCall) {
                  Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
       * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
       * be specified by overriding the virtual {_implementation} function.
       *
       * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
       * different contract through the {_delegate} function.
       *
       * The success and return data of the delegated call will be returned back to the caller of the proxy.
       */
      abstract contract Proxy {
          /**
           * @dev Delegates the current call to `implementation`.
           *
           * This function does not return to its internal call site, it will return directly to the external caller.
           */
          function _delegate(address implementation) internal virtual {
              assembly {
                  // Copy msg.data. We take full control of memory in this inline assembly
                  // block because it will not return to Solidity code. We overwrite the
                  // Solidity scratch pad at memory position 0.
                  calldatacopy(0, 0, calldatasize())
                  // Call the implementation.
                  // out and outsize are 0 because we don't know the size yet.
                  let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                  // Copy the returned data.
                  returndatacopy(0, 0, returndatasize())
                  switch result
                  // delegatecall returns 0 on error.
                  case 0 {
                      revert(0, returndatasize())
                  }
                  default {
                      return(0, returndatasize())
                  }
              }
          }
          /**
           * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
           * and {_fallback} should delegate.
           */
          function _implementation() internal view virtual returns (address);
          /**
           * @dev Delegates the current call to the address returned by `_implementation()`.
           *
           * This function does not return to its internal call site, it will return directly to the external caller.
           */
          function _fallback() internal virtual {
              _beforeFallback();
              _delegate(_implementation());
          }
          /**
           * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
           * function in the contract matches the call data.
           */
          fallback() external payable virtual {
              _fallback();
          }
          /**
           * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
           * is empty.
           */
          receive() external payable virtual {
              _fallback();
          }
          /**
           * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
           * call, or as part of the Solidity `fallback` or `receive` functions.
           *
           * If overridden should call `super._beforeFallback()`.
           */
          function _beforeFallback() internal virtual {}
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
      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 functionCall(target, data, "Address: low-level call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
           * `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, 0, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but also transferring `value` wei to `target`.
           *
           * Requirements:
           *
           * - the calling contract must have an ETH balance of at least `value`.
           * - the called Solidity function must be `payable`.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
          }
          /**
           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
           * with `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(address(this).balance >= value, "Address: insufficient balance for call");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{value: value}(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
              return functionDelegateCall(target, data, "Address: low-level delegate call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(isContract(target), "Address: delegate call to non-contract");
              (bool success, bytes memory returndata) = target.delegatecall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
           * revert reason using the provided one.
           *
           * _Available since v4.3._
           */
          function verifyCallResult(
              bool success,
              bytes memory returndata,
              string memory errorMessage
          ) internal pure returns (bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @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 v4.7.0) (utils/StorageSlot.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev Library for reading and writing primitive types to specific storage slots.
       *
       * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
       * This library helps with reading and writing to such slots without the need for inline assembly.
       *
       * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
       *
       * Example usage to set ERC1967 implementation slot:
       * ```
       * contract ERC1967 {
       *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
       *
       *     function _getImplementation() internal view returns (address) {
       *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
       *     }
       *
       *     function _setImplementation(address newImplementation) internal {
       *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
       *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
       *     }
       * }
       * ```
       *
       * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
       */
      library StorageSlot {
          struct AddressSlot {
              address value;
          }
          struct BooleanSlot {
              bool value;
          }
          struct Bytes32Slot {
              bytes32 value;
          }
          struct Uint256Slot {
              uint256 value;
          }
          /**
           * @dev Returns an `AddressSlot` with member `value` located at `slot`.
           */
          function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
           */
          function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
           */
          function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
           */
          function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
      }
      

      File 2 of 3: PendleVotingControllerUpg
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
      pragma solidity ^0.8.2;
      import "../../utils/AddressUpgradeable.sol";
      /**
       * @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]
       * ```
       * 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 Indicates that the contract has been initialized.
           * @custom:oz-retyped-from bool
           */
          uint8 private _initialized;
          /**
           * @dev Indicates that the contract is in the process of being initialized.
           */
          bool private _initializing;
          /**
           * @dev Triggered when the contract has been initialized or reinitialized.
           */
          event Initialized(uint8 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. Equivalent to `reinitializer(1)`.
           */
          modifier initializer() {
              bool isTopLevelCall = !_initializing;
              require(
                  (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
                  "Initializable: contract is already initialized"
              );
              _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.
           *
           * `initializer` is equivalent to `reinitializer(1)`, so 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.
           *
           * 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.
           */
          modifier reinitializer(uint8 version) {
              require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
              _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() {
              require(_initializing, "Initializable: contract is not initializing");
              _;
          }
          /**
           * @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.
           */
          function _disableInitializers() internal virtual {
              require(!_initializing, "Initializable: contract is initializing");
              if (_initialized < type(uint8).max) {
                  _initialized = type(uint8).max;
                  emit Initialized(type(uint8).max);
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
      pragma solidity ^0.8.1;
      /**
       * @dev Collection of functions related to the address type
       */
      library AddressUpgradeable {
          /**
           * @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 functionCall(target, data, "Address: low-level call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
           * `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, 0, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but also transferring `value` wei to `target`.
           *
           * Requirements:
           *
           * - the calling contract must have an ETH balance of at least `value`.
           * - the called Solidity function must be `payable`.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
          }
          /**
           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
           * with `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(address(this).balance >= value, "Address: insufficient balance for call");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{value: value}(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
           * revert reason using the provided one.
           *
           * _Available since v4.3._
           */
          function verifyCallResult(
              bool success,
              bytes memory returndata,
              string memory errorMessage
          ) internal pure returns (bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @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 v4.5.0) (interfaces/draft-IERC1822.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
       * proxy whose upgrades are fully controlled by the current implementation.
       */
      interface IERC1822Proxiable {
          /**
           * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
           * address.
           *
           * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
           * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
           * function revert if invoked through a proxy.
           */
          function proxiableUUID() external view returns (bytes32);
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev This is the interface that {BeaconProxy} expects of its beacon.
       */
      interface IBeacon {
          /**
           * @dev Must return an address that can be used as a delegate call target.
           *
           * {BeaconProxy} will check that this address is a contract.
           */
          function implementation() external view returns (address);
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
      pragma solidity ^0.8.2;
      import "../beacon/IBeacon.sol";
      import "../../interfaces/draft-IERC1822.sol";
      import "../../utils/Address.sol";
      import "../../utils/StorageSlot.sol";
      /**
       * @dev This abstract contract provides getters and event emitting update functions for
       * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
       *
       * _Available since v4.1._
       *
       * @custom:oz-upgrades-unsafe-allow delegatecall
       */
      abstract contract ERC1967Upgrade {
          // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
          bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
          /**
           * @dev Storage slot with the address of the current implementation.
           * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
           * validated in the constructor.
           */
          bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
          /**
           * @dev Emitted when the implementation is upgraded.
           */
          event Upgraded(address indexed implementation);
          /**
           * @dev Returns the current implementation address.
           */
          function _getImplementation() internal view returns (address) {
              return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
          }
          /**
           * @dev Stores a new address in the EIP1967 implementation slot.
           */
          function _setImplementation(address newImplementation) private {
              require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
              StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
          }
          /**
           * @dev Perform implementation upgrade
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeTo(address newImplementation) internal {
              _setImplementation(newImplementation);
              emit Upgraded(newImplementation);
          }
          /**
           * @dev Perform implementation upgrade with additional setup call.
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeToAndCall(
              address newImplementation,
              bytes memory data,
              bool forceCall
          ) internal {
              _upgradeTo(newImplementation);
              if (data.length > 0 || forceCall) {
                  Address.functionDelegateCall(newImplementation, data);
              }
          }
          /**
           * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
           *
           * Emits an {Upgraded} event.
           */
          function _upgradeToAndCallUUPS(
              address newImplementation,
              bytes memory data,
              bool forceCall
          ) internal {
              // Upgrades from old implementations will perform a rollback test. This test requires the new
              // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
              // this special case will break upgrade paths from old UUPS implementation to new ones.
              if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                  _setImplementation(newImplementation);
              } else {
                  try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                      require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                  } catch {
                      revert("ERC1967Upgrade: new implementation is not UUPS");
                  }
                  _upgradeToAndCall(newImplementation, data, forceCall);
              }
          }
          /**
           * @dev Storage slot with the admin of the contract.
           * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
           * validated in the constructor.
           */
          bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
          /**
           * @dev Emitted when the admin account has changed.
           */
          event AdminChanged(address previousAdmin, address newAdmin);
          /**
           * @dev Returns the current admin.
           */
          function _getAdmin() internal view returns (address) {
              return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
          }
          /**
           * @dev Stores a new address in the EIP1967 admin slot.
           */
          function _setAdmin(address newAdmin) private {
              require(newAdmin != address(0), "ERC1967: new admin is the zero address");
              StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
          }
          /**
           * @dev Changes the admin of the proxy.
           *
           * Emits an {AdminChanged} event.
           */
          function _changeAdmin(address newAdmin) internal {
              emit AdminChanged(_getAdmin(), newAdmin);
              _setAdmin(newAdmin);
          }
          /**
           * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
           * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
           */
          bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
          /**
           * @dev Emitted when the beacon is upgraded.
           */
          event BeaconUpgraded(address indexed beacon);
          /**
           * @dev Returns the current beacon.
           */
          function _getBeacon() internal view returns (address) {
              return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
          }
          /**
           * @dev Stores a new beacon in the EIP1967 beacon slot.
           */
          function _setBeacon(address newBeacon) private {
              require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
              require(
                  Address.isContract(IBeacon(newBeacon).implementation()),
                  "ERC1967: beacon implementation is not a contract"
              );
              StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
          }
          /**
           * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
           * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
           *
           * Emits a {BeaconUpgraded} event.
           */
          function _upgradeBeaconToAndCall(
              address newBeacon,
              bytes memory data,
              bool forceCall
          ) internal {
              _setBeacon(newBeacon);
              emit BeaconUpgraded(newBeacon);
              if (data.length > 0 || forceCall) {
                  Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)
      pragma solidity ^0.8.0;
      import "../../interfaces/draft-IERC1822.sol";
      import "../ERC1967/ERC1967Upgrade.sol";
      /**
       * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
       * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
       *
       * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
       * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
       * `UUPSUpgradeable` with a custom implementation of upgrades.
       *
       * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
       *
       * _Available since v4.1._
       */
      abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
          /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
          address private immutable __self = address(this);
          /**
           * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
           * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
           * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
           * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
           * fail.
           */
          modifier onlyProxy() {
              require(address(this) != __self, "Function must be called through delegatecall");
              require(_getImplementation() == __self, "Function must be called through active proxy");
              _;
          }
          /**
           * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
           * callable on the implementing contract but not through proxies.
           */
          modifier notDelegated() {
              require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
              _;
          }
          /**
           * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
           * implementation. It is used to validate that the this implementation remains valid after an upgrade.
           *
           * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
           * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
           * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
           */
          function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
              return _IMPLEMENTATION_SLOT;
          }
          /**
           * @dev Upgrade the implementation of the proxy to `newImplementation`.
           *
           * Calls {_authorizeUpgrade}.
           *
           * Emits an {Upgraded} event.
           */
          function upgradeTo(address newImplementation) external virtual onlyProxy {
              _authorizeUpgrade(newImplementation);
              _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
          }
          /**
           * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
           * encoded in `data`.
           *
           * Calls {_authorizeUpgrade}.
           *
           * Emits an {Upgraded} event.
           */
          function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
              _authorizeUpgrade(newImplementation);
              _upgradeToAndCallUUPS(newImplementation, data, true);
          }
          /**
           * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
           * {upgradeTo} and {upgradeToAndCall}.
           *
           * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
           *
           * ```solidity
           * function _authorizeUpgrade(address) internal override onlyOwner {}
           * ```
           */
          function _authorizeUpgrade(address newImplementation) internal virtual;
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
      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 functionCall(target, data, "Address: low-level call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
           * `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, 0, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but also transferring `value` wei to `target`.
           *
           * Requirements:
           *
           * - the calling contract must have an ETH balance of at least `value`.
           * - the called Solidity function must be `payable`.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
          }
          /**
           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
           * with `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(address(this).balance >= value, "Address: insufficient balance for call");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{value: value}(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
              return functionDelegateCall(target, data, "Address: low-level delegate call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(isContract(target), "Address: delegate call to non-contract");
              (bool success, bytes memory returndata) = target.delegatecall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
           * revert reason using the provided one.
           *
           * _Available since v4.3._
           */
          function verifyCallResult(
              bool success,
              bytes memory returndata,
              string memory errorMessage
          ) internal pure returns (bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @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 v4.7.0) (utils/StorageSlot.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev Library for reading and writing primitive types to specific storage slots.
       *
       * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
       * This library helps with reading and writing to such slots without the need for inline assembly.
       *
       * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
       *
       * Example usage to set ERC1967 implementation slot:
       * ```
       * contract ERC1967 {
       *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
       *
       *     function _getImplementation() internal view returns (address) {
       *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
       *     }
       *
       *     function _setImplementation(address newImplementation) internal {
       *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
       *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
       *     }
       * }
       * ```
       *
       * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
       */
      library StorageSlot {
          struct AddressSlot {
              address value;
          }
          struct BooleanSlot {
              bool value;
          }
          struct Bytes32Slot {
              bytes32 value;
          }
          struct Uint256Slot {
              uint256 value;
          }
          /**
           * @dev Returns an `AddressSlot` with member `value` located at `slot`.
           */
          function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
           */
          function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
           */
          function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
          /**
           * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
           */
          function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
              /// @solidity memory-safe-assembly
              assembly {
                  r.slot := slot
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableMap.sol)
      pragma solidity ^0.8.0;
      import "./EnumerableSet.sol";
      /**
       * @dev Library for managing an enumerable variant of Solidity's
       * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
       * type.
       *
       * Maps have the following properties:
       *
       * - Entries are added, removed, and checked for existence in constant time
       * (O(1)).
       * - Entries are enumerated in O(n). No guarantees are made on the ordering.
       *
       * ```
       * contract Example {
       *     // Add the library methods
       *     using EnumerableMap for EnumerableMap.UintToAddressMap;
       *
       *     // Declare a set state variable
       *     EnumerableMap.UintToAddressMap private myMap;
       * }
       * ```
       *
       * The following map types are supported:
       *
       * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
       * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
       * - `bytes32 -> bytes32` (`Bytes32ToBytes32`) since v4.6.0
       * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
       * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
       *
       * [WARNING]
       * ====
       *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
       *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
       *
       *  In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an array of EnumerableMap.
       * ====
       */
      library EnumerableMap {
          using EnumerableSet for EnumerableSet.Bytes32Set;
          // To implement this library for multiple types with as little code
          // repetition as possible, we write it in terms of a generic Map type with
          // bytes32 keys and values.
          // The Map implementation uses private functions, and user-facing
          // implementations (such as Uint256ToAddressMap) are just wrappers around
          // the underlying Map.
          // This means that we can only create new EnumerableMaps for types that fit
          // in bytes32.
          struct Bytes32ToBytes32Map {
              // Storage of keys
              EnumerableSet.Bytes32Set _keys;
              mapping(bytes32 => bytes32) _values;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              Bytes32ToBytes32Map storage map,
              bytes32 key,
              bytes32 value
          ) internal returns (bool) {
              map._values[key] = value;
              return map._keys.add(key);
          }
          /**
           * @dev Removes a key-value pair from a map. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
              delete map._values[key];
              return map._keys.remove(key);
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
              return map._keys.contains(key);
          }
          /**
           * @dev Returns the number of key-value pairs in the map. O(1).
           */
          function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
              return map._keys.length();
          }
          /**
           * @dev Returns the key-value pair stored at position `index` in the map. O(1).
           *
           * Note that there are no guarantees on the ordering of entries inside the
           * array, and it may change when more entries are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
              bytes32 key = map._keys.at(index);
              return (key, map._values[key]);
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
              bytes32 value = map._values[key];
              if (value == bytes32(0)) {
                  return (contains(map, key), bytes32(0));
              } else {
                  return (true, value);
              }
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
              bytes32 value = map._values[key];
              require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
              return value;
          }
          /**
           * @dev Same as {_get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {_tryGet}.
           */
          function get(
              Bytes32ToBytes32Map storage map,
              bytes32 key,
              string memory errorMessage
          ) internal view returns (bytes32) {
              bytes32 value = map._values[key];
              require(value != 0 || contains(map, key), errorMessage);
              return value;
          }
          // UintToUintMap
          struct UintToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              UintToUintMap storage map,
              uint256 key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, bytes32(key), bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
              return remove(map._inner, bytes32(key));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
              return contains(map._inner, bytes32(key));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(UintToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (uint256(key), uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(key)));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              UintToUintMap storage map,
              uint256 key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(key), errorMessage));
          }
          // UintToAddressMap
          struct UintToAddressMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              UintToAddressMap storage map,
              uint256 key,
              address value
          ) internal returns (bool) {
              return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
              return remove(map._inner, bytes32(key));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
              return contains(map._inner, bytes32(key));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(UintToAddressMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (uint256(key), address(uint160(uint256(value))));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           *
           * _Available since v3.4._
           */
          function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
              return (success, address(uint160(uint256(value))));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
              return address(uint160(uint256(get(map._inner, bytes32(key)))));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              UintToAddressMap storage map,
              uint256 key,
              string memory errorMessage
          ) internal view returns (address) {
              return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
          }
          // AddressToUintMap
          struct AddressToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              AddressToUintMap storage map,
              address key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(AddressToUintMap storage map, address key) internal returns (bool) {
              return remove(map._inner, bytes32(uint256(uint160(key))));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
              return contains(map._inner, bytes32(uint256(uint160(key))));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(AddressToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (address(uint160(uint256(key))), uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              AddressToUintMap storage map,
              address key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
          }
          // Bytes32ToUintMap
          struct Bytes32ToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              Bytes32ToUintMap storage map,
              bytes32 key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, key, bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
              return remove(map._inner, key);
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
              return contains(map._inner, key);
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (key, uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, key);
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
              return uint256(get(map._inner, key));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              Bytes32ToUintMap storage map,
              bytes32 key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, key, errorMessage));
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev Library for managing
       * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
       * types.
       *
       * Sets have the following properties:
       *
       * - Elements are added, removed, and checked for existence in constant time
       * (O(1)).
       * - Elements are enumerated in O(n). No guarantees are made on the ordering.
       *
       * ```
       * contract Example {
       *     // Add the library methods
       *     using EnumerableSet for EnumerableSet.AddressSet;
       *
       *     // Declare a set state variable
       *     EnumerableSet.AddressSet private mySet;
       * }
       * ```
       *
       * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
       * and `uint256` (`UintSet`) are supported.
       *
       * [WARNING]
       * ====
       *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
       *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
       *
       *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
       * ====
       */
      library EnumerableSet {
          // To implement this library for multiple types with as little code
          // repetition as possible, we write it in terms of a generic Set type with
          // bytes32 values.
          // The Set implementation uses private functions, and user-facing
          // implementations (such as AddressSet) are just wrappers around the
          // underlying Set.
          // This means that we can only create new EnumerableSets for types that fit
          // in bytes32.
          struct Set {
              // Storage of set values
              bytes32[] _values;
              // Position of the value in the `values` array, plus 1 because index 0
              // means a value is not in the set.
              mapping(bytes32 => uint256) _indexes;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function _add(Set storage set, bytes32 value) private returns (bool) {
              if (!_contains(set, value)) {
                  set._values.push(value);
                  // The value is stored at length-1, but we add 1 to all indexes
                  // and use 0 as a sentinel value
                  set._indexes[value] = set._values.length;
                  return true;
              } else {
                  return false;
              }
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function _remove(Set storage set, bytes32 value) private returns (bool) {
              // We read and store the value's index to prevent multiple reads from the same storage slot
              uint256 valueIndex = set._indexes[value];
              if (valueIndex != 0) {
                  // Equivalent to contains(set, value)
                  // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
                  // the array, and then remove the last element (sometimes called as 'swap and pop').
                  // This modifies the order of the array, as noted in {at}.
                  uint256 toDeleteIndex = valueIndex - 1;
                  uint256 lastIndex = set._values.length - 1;
                  if (lastIndex != toDeleteIndex) {
                      bytes32 lastValue = set._values[lastIndex];
                      // Move the last value to the index where the value to delete is
                      set._values[toDeleteIndex] = lastValue;
                      // Update the index for the moved value
                      set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
                  }
                  // Delete the slot where the moved value was stored
                  set._values.pop();
                  // Delete the index for the deleted slot
                  delete set._indexes[value];
                  return true;
              } else {
                  return false;
              }
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function _contains(Set storage set, bytes32 value) private view returns (bool) {
              return set._indexes[value] != 0;
          }
          /**
           * @dev Returns the number of values on the set. O(1).
           */
          function _length(Set storage set) private view returns (uint256) {
              return set._values.length;
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function _at(Set storage set, uint256 index) private view returns (bytes32) {
              return set._values[index];
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function _values(Set storage set) private view returns (bytes32[] memory) {
              return set._values;
          }
          // Bytes32Set
          struct Bytes32Set {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _add(set._inner, value);
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _remove(set._inner, value);
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
              return _contains(set._inner, value);
          }
          /**
           * @dev Returns the number of values in the set. O(1).
           */
          function length(Bytes32Set storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
              return _at(set._inner, index);
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
              return _values(set._inner);
          }
          // AddressSet
          struct AddressSet {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(AddressSet storage set, address value) internal returns (bool) {
              return _add(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(AddressSet storage set, address value) internal returns (bool) {
              return _remove(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(AddressSet storage set, address value) internal view returns (bool) {
              return _contains(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Returns the number of values in the set. O(1).
           */
          function length(AddressSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(AddressSet storage set, uint256 index) internal view returns (address) {
              return address(uint160(uint256(_at(set._inner, index))));
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(AddressSet storage set) internal view returns (address[] memory) {
              bytes32[] memory store = _values(set._inner);
              address[] memory result;
              /// @solidity memory-safe-assembly
              assembly {
                  result := store
              }
              return result;
          }
          // UintSet
          struct UintSet {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(UintSet storage set, uint256 value) internal returns (bool) {
              return _add(set._inner, bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(UintSet storage set, uint256 value) internal returns (bool) {
              return _remove(set._inner, bytes32(value));
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(UintSet storage set, uint256 value) internal view returns (bool) {
              return _contains(set._inner, bytes32(value));
          }
          /**
           * @dev Returns the number of values on the set. O(1).
           */
          function length(UintSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintSet storage set, uint256 index) internal view returns (uint256) {
              return uint256(_at(set._inner, index));
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(UintSet storage set) internal view returns (uint256[] memory) {
              bytes32[] memory store = _values(set._inner);
              uint256[] memory result;
              /// @solidity memory-safe-assembly
              assembly {
                  result := store
              }
              return result;
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
      contract BoringOwnableUpgradeableData {
          address public owner;
          address public pendingOwner;
      }
      abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
          function __BoringOwnable_init() internal onlyInitializing {
              owner = msg.sender;
          }
          /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
          /// Can only be invoked by the current `owner`.
          /// @param newOwner Address of the new owner.
          /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
          /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
          function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
              if (direct) {
                  // Checks
                  require(newOwner != address(0) || renounce, "Ownable: zero address");
                  // Effects
                  emit OwnershipTransferred(owner, newOwner);
                  owner = newOwner;
                  pendingOwner = address(0);
              } else {
                  // Effects
                  pendingOwner = newOwner;
              }
          }
          /// @notice Needs to be called by `pendingOwner` to claim ownership.
          function claimOwnership() public {
              address _pendingOwner = pendingOwner;
              // Checks
              require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
              // Effects
              emit OwnershipTransferred(owner, _pendingOwner);
              owner = _pendingOwner;
              pendingOwner = address(0);
          }
          /// @notice Only allows the `owner` to execute the function.
          modifier onlyOwner() {
              require(msg.sender == owner, "Ownable: caller is not the owner");
              _;
          }
          uint256[48] private __gap;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      library Errors {
          // BulkSeller
          error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
          error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
          error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
          error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
          error BulkNotMaintainer();
          error BulkNotAdmin();
          error BulkSellerAlreadyExisted(address token, address SY, address bulk);
          error BulkSellerInvalidToken(address token, address SY);
          error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
          error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
          // APPROX
          error ApproxFail();
          error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
          error ApproxBinarySearchInputInvalid(
              uint256 approxGuessMin,
              uint256 approxGuessMax,
              uint256 minGuessMin,
              uint256 maxGuessMax
          );
          // MARKET + MARKET MATH CORE
          error MarketExpired();
          error MarketZeroAmountsInput();
          error MarketZeroAmountsOutput();
          error MarketZeroLnImpliedRate();
          error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
          error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
          error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
          error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
          error MarketExchangeRateBelowOne(int256 exchangeRate);
          error MarketProportionMustNotEqualOne();
          error MarketRateScalarBelowZero(int256 rateScalar);
          error MarketScalarRootBelowZero(int256 scalarRoot);
          error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
          error OracleUninitialized();
          error OracleTargetTooOld(uint32 target, uint32 oldest);
          error OracleZeroCardinality();
          error MarketFactoryExpiredPt();
          error MarketFactoryInvalidPt();
          error MarketFactoryMarketExists();
          error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
          error MarketFactoryReserveFeePercentTooHigh(
              uint8 reserveFeePercent,
              uint8 maxReserveFeePercent
          );
          error MarketFactoryZeroTreasury();
          error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
          // ROUTER
          error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
          error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
          error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
          error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
          error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
          error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
          error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
          error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
          error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
          error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
          error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
          error RouterTimeRangeZero();
          error RouterCallbackNotPendleMarket(address caller);
          error RouterInvalidAction(bytes4 selector);
          error RouterInvalidFacet(address facet);
          error RouterKyberSwapDataZero();
          // YIELD CONTRACT
          error YCExpired();
          error YCNotExpired();
          error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
          error YCNothingToRedeem();
          error YCPostExpiryDataNotSet();
          error YCNoFloatingSy();
          // YieldFactory
          error YCFactoryInvalidExpiry();
          error YCFactoryYieldContractExisted();
          error YCFactoryZeroExpiryDivisor();
          error YCFactoryZeroTreasury();
          error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
          error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
          // SY
          error SYInvalidTokenIn(address token);
          error SYInvalidTokenOut(address token);
          error SYZeroDeposit();
          error SYZeroRedeem();
          error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
          error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          // SY-specific
          error SYQiTokenMintFailed(uint256 errCode);
          error SYQiTokenRedeemFailed(uint256 errCode);
          error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
          error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
          error SYCurveInvalidPid();
          error SYCurve3crvPoolNotFound();
          error SYApeDepositAmountTooSmall(uint256 amountDeposited);
          error SYBalancerInvalidPid();
          error SYInvalidRewardToken(address token);
          error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
          error SYBalancerReentrancy();
          // Liquidity Mining
          error VCInactivePool(address pool);
          error VCPoolAlreadyActive(address pool);
          error VCZeroVePendle(address user);
          error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
          error VCEpochNotFinalized(uint256 wTime);
          error VCPoolAlreadyAddAndRemoved(address pool);
          error VEInvalidNewExpiry(uint256 newExpiry);
          error VEExceededMaxLockTime();
          error VEInsufficientLockTime();
          error VENotAllowedReduceExpiry();
          error VEZeroAmountLocked();
          error VEPositionNotExpired();
          error VEZeroPosition();
          error VEZeroSlope(uint128 bias, uint128 slope);
          error VEReceiveOldSupply(uint256 msgTime);
          error GCNotPendleMarket(address caller);
          error GCNotVotingController(address caller);
          error InvalidWTime(uint256 wTime);
          error ExpiryInThePast(uint256 expiry);
          error ChainNotSupported(uint256 chainId);
          error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
          error FDEpochLengthMismatch();
          error FDInvalidPool(address pool);
          error FDPoolAlreadyExists(address pool);
          error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
          error FDInvalidStartEpoch(uint256 startEpoch);
          error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
          error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
          error BDInvalidEpoch(uint256 epoch, uint256 startTime);
          // Cross-Chain
          error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
          error MsgNotFromReceiveEndpoint(address sender);
          error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
          error ApproxDstExecutionGasNotSet();
          error InvalidRetryData();
          // GENERIC MSG
          error ArrayLengthMismatch();
          error ArrayEmpty();
          error ArrayOutOfBounds();
          error ZeroAddress();
          error FailedToSendEther();
          error InvalidMerkleProof();
          error OnlyLayerZeroEndpoint();
          error OnlyYT();
          error OnlyYCFactory();
          error OnlyWhitelisted();
          // Swap Aggregator
          error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
          error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      // This program is free software: you can redistribute it and/or modify
      // it under the terms of the GNU General Public License as published by
      // the Free Software Foundation, either version 3 of the License, or
      // (at your option) any later version.
      // This program is distributed in the hope that it will be useful,
      // but WITHOUT ANY WARRANTY; without even the implied warranty of
      // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      // GNU General Public License for more details.
      // You should have received a copy of the GNU General Public License
      // along with this program.  If not, see <http://www.gnu.org/licenses/>.
      pragma solidity 0.8.17;
      /* solhint-disable private-vars-leading-underscore, reason-string */
      library Math {
          uint256 internal constant ONE = 1e18; // 18 decimal places
          int256 internal constant IONE = 1e18; // 18 decimal places
          function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
              unchecked {
                  return (a >= b ? a - b : 0);
              }
          }
          function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
              require(a >= b, "negative");
              return a - b; // no unchecked since if b is very negative, a - b might overflow
          }
          function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 product = a * b;
              unchecked {
                  return product / ONE;
              }
          }
          function mulDown(int256 a, int256 b) internal pure returns (int256) {
              int256 product = a * b;
              unchecked {
                  return product / IONE;
              }
          }
          function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 aInflated = a * ONE;
              unchecked {
                  return aInflated / b;
              }
          }
          function divDown(int256 a, int256 b) internal pure returns (int256) {
              int256 aInflated = a * IONE;
              unchecked {
                  return aInflated / b;
              }
          }
          function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
              return (a + b - 1) / b;
          }
          // @author Uniswap
          function sqrt(uint256 y) internal pure returns (uint256 z) {
              if (y > 3) {
                  z = y;
                  uint256 x = y / 2 + 1;
                  while (x < z) {
                      z = x;
                      x = (y / x + x) / 2;
                  }
              } else if (y != 0) {
                  z = 1;
              }
          }
          function abs(int256 x) internal pure returns (uint256) {
              return uint256(x > 0 ? x : -x);
          }
          function neg(int256 x) internal pure returns (int256) {
              return x * (-1);
          }
          function neg(uint256 x) internal pure returns (int256) {
              return Int(x) * (-1);
          }
          function max(uint256 x, uint256 y) internal pure returns (uint256) {
              return (x > y ? x : y);
          }
          function max(int256 x, int256 y) internal pure returns (int256) {
              return (x > y ? x : y);
          }
          function min(uint256 x, uint256 y) internal pure returns (uint256) {
              return (x < y ? x : y);
          }
          function min(int256 x, int256 y) internal pure returns (int256) {
              return (x < y ? x : y);
          }
          /*///////////////////////////////////////////////////////////////
                                     SIGNED CASTS
          //////////////////////////////////////////////////////////////*/
          function Int(uint256 x) internal pure returns (int256) {
              require(x <= uint256(type(int256).max));
              return int256(x);
          }
          function Int128(int256 x) internal pure returns (int128) {
              require(type(int128).min <= x && x <= type(int128).max);
              return int128(x);
          }
          function Int128(uint256 x) internal pure returns (int128) {
              return Int128(Int(x));
          }
          /*///////////////////////////////////////////////////////////////
                                     UNSIGNED CASTS
          //////////////////////////////////////////////////////////////*/
          function Uint(int256 x) internal pure returns (uint256) {
              require(x >= 0);
              return uint256(x);
          }
          function Uint32(uint256 x) internal pure returns (uint32) {
              require(x <= type(uint32).max);
              return uint32(x);
          }
          function Uint112(uint256 x) internal pure returns (uint112) {
              require(x <= type(uint112).max);
              return uint112(x);
          }
          function Uint96(uint256 x) internal pure returns (uint96) {
              require(x <= type(uint96).max);
              return uint96(x);
          }
          function Uint128(uint256 x) internal pure returns (uint128) {
              require(x <= type(uint128).max);
              return uint128(x);
          }
          function isAApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
              return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
          }
          function isAGreaterApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
              return a >= b && a <= mulDown(b, ONE + eps);
          }
          function isASmallerApproxB(uint256 a, uint256 b, uint256 eps) internal pure returns (bool) {
              return a <= b && a >= mulDown(b, ONE - eps);
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      library MiniHelpers {
          function isCurrentlyExpired(uint256 expiry) internal view returns (bool) {
              return (expiry <= block.timestamp);
          }
          function isExpired(uint256 expiry, uint256 blockTime) internal pure returns (bool) {
              return (expiry <= blockTime);
          }
          function isTimeInThePast(uint256 timestamp) internal view returns (bool) {
              return (timestamp <= block.timestamp); // same definition as isCurrentlyExpired
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      interface IPGaugeController {
          event MarketClaimReward(address indexed market, uint256 amount);
          event ReceiveVotingResults(uint128 indexed wTime, address[] markets, uint256[] pendleAmounts);
          event UpdateMarketReward(
              address indexed market,
              uint256 pendlePerSec,
              uint256 incentiveEndsAt
          );
          function fundPendle(uint256 amount) external;
          function withdrawPendle(uint256 amount) external;
          function pendle() external returns (address);
          function redeemMarketReward() external;
          function rewardData(
              address pool
          ) external view returns (uint128 pendlePerSec, uint128, uint128, uint128);
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "./IPGaugeController.sol";
      interface IPGaugeControllerMainchain is IPGaugeController {
          function updateVotingResults(
              uint128 wTime,
              address[] calldata markets,
              uint256[] calldata pendleSpeeds
          ) external;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity >=0.8.0;
      interface IPMsgSendEndpoint {
          function calcFee(
              address dstAddress,
              uint256 dstChainId,
              bytes memory payload,
              uint256 estimatedGasAmount
          ) external view returns (uint256 fee);
          function sendMessage(
              address dstAddress,
              uint256 dstChainId,
              bytes calldata payload,
              uint256 estimatedGasAmount
          ) external payable;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      interface IPVeToken {
          // ============= USER INFO =============
          function balanceOf(address user) external view returns (uint128);
          function positionData(address user) external view returns (uint128 amount, uint128 expiry);
          // ============= META DATA =============
          function totalSupplyStored() external view returns (uint128);
          function totalSupplyCurrent() external returns (uint128);
          function totalSupplyAndBalanceCurrent(address user) external returns (uint128, uint128);
      }
      pragma solidity 0.8.17;
      import "../LiquidityMining/libraries/VeBalanceLib.sol";
      import "../LiquidityMining/libraries/VeHistoryLib.sol";
      interface IPVotingController {
          event AddPool(uint64 indexed chainId, address indexed pool);
          event RemovePool(uint64 indexed chainId, address indexed pool);
          event Vote(address indexed user, address indexed pool, uint64 weight, VeBalance vote);
          event PoolVoteChange(address indexed pool, VeBalance vote);
          event SetPendlePerSec(uint256 newPendlePerSec);
          event BroadcastResults(
              uint64 indexed chainId,
              uint128 indexed wTime,
              uint128 totalPendlePerSec
          );
          function applyPoolSlopeChanges(address pool) external;
          /// @notice deprecated, only kept for compatibility reasons
          function getUserPoolHistoryLength(address user, address pool) external view returns (uint256);
          /// @notice deprecated, only kept for compatibility reasons
          function getUserPoolHistoryAt(
              address user,
              address pool,
              uint256 index
          ) external view returns (Checkpoint memory);
          function getWeekData(uint128 wTime, address[] calldata pools)
              external
              view
              returns (
                  bool isEpochFinalized,
                  uint128 totalVotes,
                  uint128[] memory poolVotes
              );
          function getPoolTotalVoteAt(address pool, uint128 wTime) external view returns (uint128);
          function finalizeEpoch() external;
          function getBroadcastResultFee(uint64 chainId) external view returns (uint256);
          function broadcastResults(uint64 chainId) external payable;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../interfaces/IPMsgSendEndpoint.sol";
      import "../../core/libraries/BoringOwnableUpgradeable.sol";
      import "../../core/libraries/Errors.sol";
      import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
      // solhint-disable no-empty-blocks
      abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
          using EnumerableMap for EnumerableMap.UintToAddressMap;
          uint256 public approxDstExecutionGas;
          IPMsgSendEndpoint public immutable pendleMsgSendEndpoint;
          // destinationContracts mapping contains one address for each chainId only
          EnumerableMap.UintToAddressMap internal destinationContracts;
          uint256[100] private __gap;
          modifier refundUnusedEth() {
              _;
              if (address(this).balance > 0) {
                  AddressUpgradeable.sendValue(payable(msg.sender), address(this).balance);
              }
          }
          constructor(address _pendleMsgSendEndpoint, uint256 _approxDstExecutionGas) {
              pendleMsgSendEndpoint = IPMsgSendEndpoint(_pendleMsgSendEndpoint);
              approxDstExecutionGas = _approxDstExecutionGas;
          }
          function _sendMessage(uint256 chainId, bytes memory message) internal {
              assert(destinationContracts.contains(chainId));
              address toAddr = destinationContracts.get(chainId);
              uint256 estimatedGasAmount = approxDstExecutionGas;
              uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message, estimatedGasAmount);
              // LM contracts won't hold ETH on its own so this is fine
              if (address(this).balance < fee)
                  revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
              pendleMsgSendEndpoint.sendMessage{ value: fee }(
                  toAddr,
                  chainId,
                  message,
                  estimatedGasAmount
              );
          }
          function addDestinationContract(
              address _address,
              uint256 _chainId
          ) external payable onlyOwner {
              destinationContracts.set(_chainId, _address);
          }
          function setApproxDstExecutionGas(uint256 gas) external onlyOwner {
              approxDstExecutionGas = gas;
          }
          function getAllDestinationContracts()
              public
              view
              returns (uint256[] memory chainIds, address[] memory addrs)
          {
              uint256 length = destinationContracts.length();
              chainIds = new uint256[](length);
              addrs = new address[](length);
              for (uint256 i = 0; i < length; ++i) {
                  (chainIds[i], addrs[i]) = destinationContracts.at(i);
              }
          }
          function _getSendMessageFee(
              uint256 chainId,
              bytes memory message
          ) internal view returns (uint256) {
              return
                  pendleMsgSendEndpoint.calcFee(
                      destinationContracts.get(chainId),
                      chainId,
                      message,
                      approxDstExecutionGas
                  );
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../core/libraries/math/Math.sol";
      import "../../core/libraries/Errors.sol";
      struct VeBalance {
          uint128 bias;
          uint128 slope;
      }
      struct LockedPosition {
          uint128 amount;
          uint128 expiry;
      }
      library VeBalanceLib {
          using Math for uint256;
          uint128 internal constant MAX_LOCK_TIME = 104 weeks;
          uint256 internal constant USER_VOTE_MAX_WEIGHT = 10 ** 18;
          function add(
              VeBalance memory a,
              VeBalance memory b
          ) internal pure returns (VeBalance memory res) {
              res.bias = a.bias + b.bias;
              res.slope = a.slope + b.slope;
          }
          function sub(
              VeBalance memory a,
              VeBalance memory b
          ) internal pure returns (VeBalance memory res) {
              res.bias = a.bias - b.bias;
              res.slope = a.slope - b.slope;
          }
          function sub(
              VeBalance memory a,
              uint128 slope,
              uint128 expiry
          ) internal pure returns (VeBalance memory res) {
              res.slope = a.slope - slope;
              res.bias = a.bias - slope * expiry;
          }
          function isExpired(VeBalance memory a) internal view returns (bool) {
              return a.slope * uint128(block.timestamp) >= a.bias;
          }
          function getCurrentValue(VeBalance memory a) internal view returns (uint128) {
              if (isExpired(a)) return 0;
              return getValueAt(a, uint128(block.timestamp));
          }
          function getValueAt(VeBalance memory a, uint128 t) internal pure returns (uint128) {
              if (a.slope * t > a.bias) {
                  return 0;
              }
              return a.bias - a.slope * t;
          }
          function getExpiry(VeBalance memory a) internal pure returns (uint128) {
              if (a.slope == 0) revert Errors.VEZeroSlope(a.bias, a.slope);
              return a.bias / a.slope;
          }
          function convertToVeBalance(
              LockedPosition memory position
          ) internal pure returns (VeBalance memory res) {
              res.slope = position.amount / MAX_LOCK_TIME;
              res.bias = res.slope * position.expiry;
          }
          function convertToVeBalance(
              LockedPosition memory position,
              uint256 weight
          ) internal pure returns (VeBalance memory res) {
              res.slope = ((position.amount * weight) / MAX_LOCK_TIME / USER_VOTE_MAX_WEIGHT).Uint128();
              res.bias = res.slope * position.expiry;
          }
          function convertToVeBalance(
              uint128 amount,
              uint128 expiry
          ) internal pure returns (uint128, uint128) {
              VeBalance memory balance = convertToVeBalance(LockedPosition(amount, expiry));
              return (balance.bias, balance.slope);
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      // Forked from OpenZeppelin (v4.5.0) (utils/Checkpoints.sol)
      pragma solidity ^0.8.0;
      import "../../core/libraries/math/Math.sol";
      import "./VeBalanceLib.sol";
      import "./WeekMath.sol";
      struct Checkpoint {
          uint128 timestamp;
          VeBalance value;
      }
      library CheckpointHelper {
          function assignWith(Checkpoint memory a, Checkpoint memory b) internal pure {
              a.timestamp = b.timestamp;
              a.value = b.value;
          }
      }
      library Checkpoints {
          struct History {
              Checkpoint[] _checkpoints;
          }
          function length(History storage self) internal view returns (uint256) {
              return self._checkpoints.length;
          }
          function get(History storage self, uint256 index) internal view returns (Checkpoint memory) {
              return self._checkpoints[index];
          }
          function push(History storage self, VeBalance memory value) internal {
              uint256 pos = self._checkpoints.length;
              if (pos > 0 && self._checkpoints[pos - 1].timestamp == WeekMath.getCurrentWeekStart()) {
                  self._checkpoints[pos - 1].value = value;
              } else {
                  self._checkpoints.push(
                      Checkpoint({ timestamp: WeekMath.getCurrentWeekStart(), value: value })
                  );
              }
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      library WeekMath {
          uint128 internal constant WEEK = 7 days;
          function getWeekStartTimestamp(uint128 timestamp) internal pure returns (uint128) {
              return (timestamp / WEEK) * WEEK;
          }
          function getCurrentWeekStart() internal view returns (uint128) {
              return getWeekStartTimestamp(uint128(block.timestamp));
          }
          function isValidWTime(uint256 time) internal pure returns (bool) {
              return time % WEEK == 0;
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "./VotingControllerStorageUpg.sol";
      import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
      import "../libraries/VeBalanceLib.sol";
      import "../../core/libraries/math/Math.sol";
      import "../../interfaces/IPGaugeControllerMainchain.sol";
      import "../../interfaces/IPVotingController.sol";
      import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
      /*
      Voting accounting:
          - For gauge controller, it will consider each message from voting controller
          as a pack of money to incentivize it during the very next WEEK (block.timestamp -> block.timestamp + WEEK)
          - If the reward duration for the last pack of money has not ended, it will combine
          the leftover reward with the current reward to distribute.
          - In the very extreme case where no one broadcast the result of week x, and at week x+1,
          the results for both are now broadcasted, then the WEEK of (block.timestamp -> WEEK)
          will receive both of the reward pack
          - Each pack of money will has it own id as timestamp, a gauge controller does not
          receive a pack of money with the same id twice, this allow governance to rebroadcast
          in case the last message was corrupted by LayerZero
      Pros:
          - If governance does not forget broadcasting the reward on the early of the week,
          the mechanism works just the same as the epoch-based one
          - If governance forget to broadcast the reward, the whole system still works normally,
          the reward is still incentivized, but only approximately fair
      Cons:
          - Does not guarantee the reward will be distributed on epoch start and end
      */
      contract PendleVotingControllerUpg is
          PendleMsgSenderAppUpg,
          VotingControllerStorageUpg,
          UUPSUpgradeable
      {
          using VeBalanceLib for VeBalance;
          using Math for uint256;
          using Math for int256;
          using EnumerableMap for EnumerableMap.UintToAddressMap;
          using EnumerableSet for EnumerableSet.AddressSet;
          constructor(
              address _vePendle,
              address _pendleMsgSendEndpoint,
              uint256 initialApproxDestinationGas
          )
              VotingControllerStorageUpg(_vePendle)
              PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) // constructor only set immutable variables
              initializer
          //solhint-disable-next-line
          {
          }
          function initialize() external initializer {
              __BoringOwnable_init();
              deployedWTime = WeekMath.getCurrentWeekStart();
          }
          /*///////////////////////////////////////////////////////////////
                      FUNCTIONS CAN BE CALLED BY ANYONE
          //////////////////////////////////////////////////////////////*/
          /**
           * @notice updates a user's vote weights, also allowing user to divide their voting power
           * across different pools
           * @param pools pools to change vote weights, if not listed then existing weight won't change
           * @param weights voting weight on each pool in `pools`, must be same length as `pools`
           * @dev A user's max voting weights is equal to `USER_VOTE_MAX_WEIGHT` (1e18). If their total
           * voted weights is less than such, then the excess weight is not counted. For such reason, a
           * user's voting power will only be fully utilized if their total voted weight is exactly 1e18.
           * @dev Reverts if, after all vote changes, the total voted weight is more than 1e18.
           * @dev A removed pool can be included, but the new weight must be 0, otherwise will revert.
           * @dev See {`VotingControllerStorageUpg - getUserData()`} for current user data.
           */
          function vote(address[] calldata pools, uint64[] calldata weights) external {
              address user = msg.sender;
              if (pools.length != weights.length) revert Errors.ArrayLengthMismatch();
              if (user != owner && vePendle.balanceOf(user) == 0) revert Errors.VCZeroVePendle(user);
              LockedPosition memory userPosition = _getUserVePendlePosition(user);
              for (uint256 i = 0; i < pools.length; ++i) {
                  if (_isPoolActive(pools[i])) applyPoolSlopeChanges(pools[i]);
                  VeBalance memory newVote = _modifyVoteWeight(user, pools[i], userPosition, weights[i]);
                  emit Vote(user, pools[i], weights[i], newVote);
              }
              uint256 totalVotedWeight = userData[user].totalVotedWeight;
              if (totalVotedWeight > VeBalanceLib.USER_VOTE_MAX_WEIGHT)
                  revert Errors.VCExceededMaxWeight(totalVotedWeight, VeBalanceLib.USER_VOTE_MAX_WEIGHT);
          }
          /**
           * @notice Process all the slopeChanges that haven't been processed & update these data into
           * poolData
           * @dev reverts if pool is not active
           * @dev if pool is already up-to-date, the function will succeed without any state updates
           */
          function applyPoolSlopeChanges(address pool) public {
              if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
              uint128 wTime = poolData[pool].lastSlopeChangeAppliedAt;
              uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
              // no state changes are expected
              if (wTime >= currentWeekStart) return;
              VeBalance memory currentVote = poolData[pool].totalVote;
              while (wTime < currentWeekStart) {
                  wTime += WEEK;
                  currentVote = currentVote.sub(poolData[pool].slopeChanges[wTime], wTime);
                  _setFinalPoolVoteForWeek(pool, wTime, currentVote.getValueAt(wTime));
              }
              _setNewVotePoolData(pool, currentVote, wTime);
          }
          /**
           * @notice finalize the voting results of all pools, up to the current epoch
           * @dev See `applyPoolSlopeChanges()` for more details
           * @dev This function might be gas-costly if there are a lot of active pools, but this can be
           * mitigated by calling `applyPoolSlopeChanges()` for each pool separately, spreading the gas
           * cost across multiple txs (although the total gas cost will be higher).
           * This is because `applyPoolSlopeChanges()` will not update anything if already up-to-date.
           */
          function finalizeEpoch() public {
              uint256 length = allActivePools.length();
              for (uint256 i = 0; i < length; ++i) {
                  applyPoolSlopeChanges(allActivePools.at(i));
              }
              _setAllPastEpochsAsFinalized();
          }
          /**
           * @notice broadcast the voting results of the current week to the chain with chainId. Can be
           * called by anyone.
           * @dev It's intentional to allow the same results to be broadcasted multiple
           * times. The receiver should be able to filter these duplicated messages
           * @dev The epoch must have already been finalized by `finalizeEpoch()`, otherwise will revert.
           */
          function broadcastResults(uint64 chainId) external payable refundUnusedEth {
              uint128 wTime = WeekMath.getCurrentWeekStart();
              if (!weekData[wTime].isEpochFinalized) revert Errors.VCEpochNotFinalized(wTime);
              _broadcastResults(chainId, wTime, pendlePerSec);
          }
          /*///////////////////////////////////////////////////////////////
                          GOVERNANCE-ONLY FUNCTIONS
          //////////////////////////////////////////////////////////////*/
          /**
           * @notice add a pool to allow users to vote. Can only be done by governance
           * @custom:gov NOTE TO GOV:
           * - Previous week's results should have been broadcasted prior to calling this function.
           * - `pool` must not have been added before (even if has been removed).
           * - `chainId` must be valid.
           */
          function addPool(uint64 chainId, address pool) external onlyOwner {
              if (_isPoolActive(pool)) revert Errors.VCPoolAlreadyActive(pool);
              if (allRemovedPools.contains(pool)) revert Errors.VCPoolAlreadyAddAndRemoved(pool);
              _addPool(chainId, pool);
              emit AddPool(chainId, pool);
          }
          /**
           * @notice remove a pool from voting. Can only be done by governance
           * @custom:gov NOTE TO GOV:
           * - Previous week's results should have been broadcasted prior to calling this function.
           * - `pool` must be currently active.
           */
          function removePool(address pool) external onlyOwner {
              if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
              uint64 chainId = poolData[pool].chainId;
              applyPoolSlopeChanges(pool);
              _removePool(pool);
              emit RemovePool(chainId, pool);
          }
          /**
           * @notice use the gov-privilege to force broadcast a message in case there are issues with LayerZero
           * @custom:gov NOTE TO GOV: gov should always call finalizeEpoch beforehand
           */
          function forceBroadcastResults(
              uint64 chainId,
              uint128 wTime,
              uint128 forcedPendlePerSec
          ) external payable onlyOwner refundUnusedEth {
              _broadcastResults(chainId, wTime, forcedPendlePerSec);
          }
          /**
           * @notice sets new pendlePerSec
           * @dev no zero checks because gov may want to stop liquidity mining
           * @custom:gov NOTE TO GOV: Should be done mid-week, well before the next broadcast to avoid
           * race condition
           */
          function setPendlePerSec(uint128 newPendlePerSec) external onlyOwner {
              pendlePerSec = newPendlePerSec;
              emit SetPendlePerSec(newPendlePerSec);
          }
          function getBroadcastResultFee(uint64 chainId) external view returns (uint256) {
              if (chainId == block.chainid) return 0; // Mainchain broadcast
              uint256 length = activeChainPools[chainId].length();
              if (length == 0) return 0;
              address[] memory pools = new address[](length);
              uint256[] memory totalPendleAmounts = new uint256[](length);
              return _getSendMessageFee(chainId, abi.encode(uint128(0), pools, totalPendleAmounts));
          }
          /*///////////////////////////////////////////////////////////////
                          INTERNAL FUNCTIONS
          //////////////////////////////////////////////////////////////*/
          /// @notice broadcast voting results of the timestamp to chainId
          function _broadcastResults(uint64 chainId, uint128 wTime, uint128 totalPendlePerSec) internal {
              uint256 totalVotes = weekData[wTime].totalVotes;
              if (totalVotes == 0) return;
              uint256 length = activeChainPools[chainId].length();
              if (length == 0) return;
              address[] memory pools = activeChainPools[chainId].values();
              uint256[] memory totalPendleAmounts = new uint256[](length);
              for (uint256 i = 0; i < length; ++i) {
                  uint256 poolVotes = weekData[wTime].poolVotes[pools[i]];
                  totalPendleAmounts[i] = (totalPendlePerSec * poolVotes * WEEK) / totalVotes;
              }
              if (chainId == block.chainid) {
                  address gaugeController = destinationContracts.get(chainId);
                  IPGaugeControllerMainchain(gaugeController).updateVotingResults(
                      wTime,
                      pools,
                      totalPendleAmounts
                  );
              } else {
                  _sendMessage(chainId, abi.encode(wTime, pools, totalPendleAmounts));
              }
              emit BroadcastResults(chainId, wTime, totalPendlePerSec);
          }
          function _getUserVePendlePosition(
              address user
          ) internal view returns (LockedPosition memory userPosition) {
              if (user == owner) {
                  (userPosition.amount, userPosition.expiry) = (
                      GOVERNANCE_PENDLE_VOTE,
                      WeekMath.getWeekStartTimestamp(uint128(block.timestamp) + MAX_LOCK_TIME)
                  );
              } else {
                  (userPosition.amount, userPosition.expiry) = vePendle.positionData(user);
              }
          }
          //solhint-disable-next-line
          function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../interfaces/IPVeToken.sol";
      import "../../interfaces/IPVotingController.sol";
      import "../libraries/VeBalanceLib.sol";
      import "../libraries/WeekMath.sol";
      import "../libraries/VeHistoryLib.sol";
      import "../../core/libraries/MiniHelpers.sol";
      import "../../core/libraries/Errors.sol";
      import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
      abstract contract VotingControllerStorageUpg is IPVotingController {
          using VeBalanceLib for VeBalance;
          using VeBalanceLib for LockedPosition;
          using EnumerableSet for EnumerableSet.AddressSet;
          using Checkpoints for Checkpoints.History;
          using WeekMath for uint128;
          struct PoolData {
              uint64 chainId;
              uint128 lastSlopeChangeAppliedAt;
              VeBalance totalVote;
              // wTime => slopeChange value
              mapping(uint128 => uint128) slopeChanges;
          }
          struct UserPoolData {
              uint64 weight;
              VeBalance vote;
          }
          struct UserData {
              uint64 totalVotedWeight;
              mapping(address => UserPoolData) voteForPools;
          }
          struct WeekData {
              bool isEpochFinalized;
              uint128 totalVotes;
              mapping(address => uint128) poolVotes;
          }
          uint128 public constant MAX_LOCK_TIME = 104 weeks;
          uint128 public constant WEEK = 1 weeks;
          uint128 public constant GOVERNANCE_PENDLE_VOTE = 10 * (10 ** 6) * (10 ** 18); // 10 mils of PENDLE
          IPVeToken public immutable vePendle;
          uint128 public deployedWTime;
          uint128 public pendlePerSec;
          EnumerableSet.AddressSet internal allActivePools;
          EnumerableSet.AddressSet internal allRemovedPools;
          // [chainId] => [pool]
          mapping(uint64 => EnumerableSet.AddressSet) internal activeChainPools;
          // [poolAddress] -> PoolData
          mapping(address => PoolData) internal poolData;
          // [wTime] => WeekData
          mapping(uint128 => WeekData) internal weekData;
          // user voting data
          mapping(address => UserData) internal userData;
          // [user][pool] => checkpoint
          mapping(address => mapping(address => Checkpoints.History)) internal __dep_userPoolHistory;
          uint256[100] private __gap;
          constructor(address _vePendle) {
              vePendle = IPVeToken(_vePendle);
          }
          /*///////////////////////////////////////////////////////////////
                                  VIEW FUNCTIONS
          //////////////////////////////////////////////////////////////*/
          function getPoolTotalVoteAt(address pool, uint128 wTime) public view returns (uint128) {
              return weekData[wTime].poolVotes[pool];
          }
          /// @notice deprecated, only kept for compatibility reasons
          function getUserPoolHistoryLength(address user, address pool) external view returns (uint256) {
              return __dep_userPoolHistory[user][pool].length();
          }
          /// @notice deprecated, only kept for compatibility reasons
          function getUserPoolHistoryAt(
              address user,
              address pool,
              uint256 index
          ) external view returns (Checkpoint memory) {
              return __dep_userPoolHistory[user][pool].get(index);
          }
          function getPoolData(
              address pool,
              uint128[] calldata wTimes
          )
              public
              view
              returns (
                  uint64 chainId,
                  uint128 lastSlopeChangeAppliedAt,
                  VeBalance memory totalVote,
                  uint128[] memory slopeChanges
              )
          {
              PoolData storage data = poolData[pool];
              (chainId, lastSlopeChangeAppliedAt, totalVote) = (
                  data.chainId,
                  data.lastSlopeChangeAppliedAt,
                  data.totalVote
              );
              slopeChanges = new uint128[](wTimes.length);
              for (uint256 i = 0; i < wTimes.length; ++i) {
                  if (!wTimes[i].isValidWTime()) revert Errors.InvalidWTime(wTimes[i]);
                  slopeChanges[i] = data.slopeChanges[wTimes[i]];
              }
          }
          function getUserData(
              address user,
              address[] calldata pools
          ) public view returns (uint64 totalVotedWeight, UserPoolData[] memory voteForPools) {
              UserData storage data = userData[user];
              totalVotedWeight = data.totalVotedWeight;
              voteForPools = new UserPoolData[](pools.length);
              for (uint256 i = 0; i < pools.length; ++i) voteForPools[i] = data.voteForPools[pools[i]];
          }
          function getWeekData(
              uint128 wTime,
              address[] calldata pools
          ) public view returns (bool isEpochFinalized, uint128 totalVotes, uint128[] memory poolVotes) {
              if (!wTime.isValidWTime()) revert Errors.InvalidWTime(wTime);
              WeekData storage data = weekData[wTime];
              (isEpochFinalized, totalVotes) = (data.isEpochFinalized, data.totalVotes);
              poolVotes = new uint128[](pools.length);
              for (uint256 i = 0; i < pools.length; ++i) poolVotes[i] = data.poolVotes[pools[i]];
          }
          function getAllActivePools() external view returns (address[] memory) {
              return allActivePools.values();
          }
          function getAllRemovedPools(
              uint256 start,
              uint256 end
          ) external view returns (uint256 lengthOfRemovedPools, address[] memory arr) {
              lengthOfRemovedPools = allRemovedPools.length();
              if (end >= lengthOfRemovedPools) revert Errors.ArrayOutOfBounds();
              arr = new address[](end - start + 1);
              for (uint256 i = start; i <= end; ++i) arr[i - start] = allRemovedPools.at(i);
          }
          function getActiveChainPools(uint64 chainId) external view returns (address[] memory) {
              return activeChainPools[chainId].values();
          }
          function getUserPoolVote(
              address user,
              address pool
          ) external view returns (UserPoolData memory) {
              return userData[user].voteForPools[pool];
          }
          /*///////////////////////////////////////////////////////////////
                      INTERNAL DATA MANIPULATION FUNCTIONS
          //////////////////////////////////////////////////////////////*/
          function _addPool(uint64 chainId, address pool) internal {
              if (!activeChainPools[chainId].add(pool)) assert(false);
              if (!allActivePools.add(pool)) assert(false);
              poolData[pool].chainId = chainId;
              poolData[pool].lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
          }
          function _removePool(address pool) internal {
              uint64 chainId = poolData[pool].chainId;
              if (!activeChainPools[chainId].remove(pool)) assert(false);
              if (!allActivePools.remove(pool)) assert(false);
              if (!allRemovedPools.add(pool)) assert(false);
              delete poolData[pool];
          }
          function _setFinalPoolVoteForWeek(address pool, uint128 wTime, uint128 vote) internal {
              weekData[wTime].totalVotes += vote;
              weekData[wTime].poolVotes[pool] = vote;
          }
          function _setNewVotePoolData(address pool, VeBalance memory vote, uint128 wTime) internal {
              poolData[pool].totalVote = vote;
              poolData[pool].lastSlopeChangeAppliedAt = wTime;
              emit PoolVoteChange(pool, vote);
          }
          /**
           * @notice modifies `user`'s vote weight on `pool`
           * @dev works by simply removing the old vote position, then adds in a fresh vote
           */
          function _modifyVoteWeight(
              address user,
              address pool,
              LockedPosition memory userPosition,
              uint64 weight
          ) internal returns (VeBalance memory newVote) {
              UserData storage uData = userData[user];
              PoolData storage pData = poolData[pool];
              VeBalance memory oldVote = uData.voteForPools[pool].vote;
              // REMOVE OLD VOTE
              if (oldVote.bias != 0) {
                  if (_isPoolActive(pool) && _isVoteActive(oldVote)) {
                      pData.totalVote = pData.totalVote.sub(oldVote);
                      pData.slopeChanges[oldVote.getExpiry()] -= oldVote.slope;
                  }
                  uData.totalVotedWeight -= uData.voteForPools[pool].weight;
                  delete uData.voteForPools[pool];
              }
              // ADD NEW VOTE
              if (weight != 0) {
                  if (!_isPoolActive(pool)) revert Errors.VCInactivePool(pool);
                  newVote = userPosition.convertToVeBalance(weight);
                  pData.totalVote = pData.totalVote.add(newVote);
                  pData.slopeChanges[newVote.getExpiry()] += newVote.slope;
                  uData.voteForPools[pool] = UserPoolData(weight, newVote);
                  uData.totalVotedWeight += weight;
              }
              emit PoolVoteChange(pool, pData.totalVote);
          }
          function _setAllPastEpochsAsFinalized() internal {
              uint128 wTime = WeekMath.getCurrentWeekStart();
              while (wTime > deployedWTime && weekData[wTime].isEpochFinalized == false) {
                  weekData[wTime].isEpochFinalized = true;
                  wTime -= WEEK;
              }
          }
          function _isPoolActive(address pool) internal view returns (bool) {
              return allActivePools.contains(pool);
          }
          /// @notice check if a vote still counts by checking if the vote is not (x,0) (in case the
          /// weight of the vote is too small) & the expiry is after the current time
          function _isVoteActive(VeBalance memory vote) internal view returns (bool) {
              return vote.slope != 0 && !MiniHelpers.isCurrentlyExpired(vote.getExpiry());
          }
      }
      

      File 3 of 3: VotingEscrowPendleMainchain
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
      pragma solidity ^0.8.2;
      import "../../utils/AddressUpgradeable.sol";
      /**
       * @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]
       * ```
       * 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 Indicates that the contract has been initialized.
           * @custom:oz-retyped-from bool
           */
          uint8 private _initialized;
          /**
           * @dev Indicates that the contract is in the process of being initialized.
           */
          bool private _initializing;
          /**
           * @dev Triggered when the contract has been initialized or reinitialized.
           */
          event Initialized(uint8 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. Equivalent to `reinitializer(1)`.
           */
          modifier initializer() {
              bool isTopLevelCall = !_initializing;
              require(
                  (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
                  "Initializable: contract is already initialized"
              );
              _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.
           *
           * `initializer` is equivalent to `reinitializer(1)`, so 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.
           *
           * 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.
           */
          modifier reinitializer(uint8 version) {
              require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
              _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() {
              require(_initializing, "Initializable: contract is not initializing");
              _;
          }
          /**
           * @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.
           */
          function _disableInitializers() internal virtual {
              require(!_initializing, "Initializable: contract is initializing");
              if (_initialized < type(uint8).max) {
                  _initialized = type(uint8).max;
                  emit Initialized(type(uint8).max);
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
      pragma solidity ^0.8.1;
      /**
       * @dev Collection of functions related to the address type
       */
      library AddressUpgradeable {
          /**
           * @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 functionCall(target, data, "Address: low-level call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
           * `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, 0, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but also transferring `value` wei to `target`.
           *
           * Requirements:
           *
           * - the calling contract must have an ETH balance of at least `value`.
           * - the called Solidity function must be `payable`.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
          }
          /**
           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
           * with `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(address(this).balance >= value, "Address: insufficient balance for call");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{value: value}(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
           * revert reason using the provided one.
           *
           * _Available since v4.3._
           */
          function verifyCallResult(
              bool success,
              bytes memory returndata,
              string memory errorMessage
          ) internal pure returns (bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @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 v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
      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.6.0) (token/ERC20/IERC20.sol)
      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
      // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
      pragma solidity ^0.8.0;
      import "../IERC20.sol";
      import "../extensions/draft-IERC20Permit.sol";
      import "../../../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;
          function safeTransfer(
              IERC20 token,
              address to,
              uint256 value
          ) internal {
              _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
          }
          function safeTransferFrom(
              IERC20 token,
              address from,
              address to,
              uint256 value
          ) internal {
              _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
          }
          /**
           * @dev Deprecated. This function has issues similar to the ones found in
           * {IERC20-approve}, and its usage is discouraged.
           *
           * Whenever possible, use {safeIncreaseAllowance} and
           * {safeDecreaseAllowance} instead.
           */
          function safeApprove(
              IERC20 token,
              address spender,
              uint256 value
          ) internal {
              // safeApprove should only be called when setting an initial allowance,
              // or when resetting it to zero. To increase and decrease it, use
              // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
              require(
                  (value == 0) || (token.allowance(address(this), spender) == 0),
                  "SafeERC20: approve from non-zero to non-zero allowance"
              );
              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
          }
          function safeIncreaseAllowance(
              IERC20 token,
              address spender,
              uint256 value
          ) internal {
              uint256 newAllowance = token.allowance(address(this), spender) + value;
              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
          }
          function safeDecreaseAllowance(
              IERC20 token,
              address spender,
              uint256 value
          ) internal {
              unchecked {
                  uint256 oldAllowance = token.allowance(address(this), spender);
                  require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                  uint256 newAllowance = oldAllowance - value;
                  _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
              }
          }
          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);
              require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
          }
          /**
           * @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, "SafeERC20: low-level call failed");
              if (returndata.length > 0) {
                  // Return data is optional
                  require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
              }
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
      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 functionCall(target, data, "Address: low-level call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
           * `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, 0, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but also transferring `value` wei to `target`.
           *
           * Requirements:
           *
           * - the calling contract must have an ETH balance of at least `value`.
           * - the called Solidity function must be `payable`.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value
          ) internal returns (bytes memory) {
              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
          }
          /**
           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
           * with `errorMessage` as a fallback revert reason when `target` reverts.
           *
           * _Available since v3.1._
           */
          function functionCallWithValue(
              address target,
              bytes memory data,
              uint256 value,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(address(this).balance >= value, "Address: insufficient balance for call");
              require(isContract(target), "Address: call to non-contract");
              (bool success, bytes memory returndata) = target.call{value: value}(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
              return functionStaticCall(target, data, "Address: low-level static call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a static call.
           *
           * _Available since v3.3._
           */
          function functionStaticCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal view returns (bytes memory) {
              require(isContract(target), "Address: static call to non-contract");
              (bool success, bytes memory returndata) = target.staticcall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
              return functionDelegateCall(target, data, "Address: low-level delegate call failed");
          }
          /**
           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
           * but performing a delegate call.
           *
           * _Available since v3.4._
           */
          function functionDelegateCall(
              address target,
              bytes memory data,
              string memory errorMessage
          ) internal returns (bytes memory) {
              require(isContract(target), "Address: delegate call to non-contract");
              (bool success, bytes memory returndata) = target.delegatecall(data);
              return verifyCallResult(success, returndata, errorMessage);
          }
          /**
           * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
           * revert reason using the provided one.
           *
           * _Available since v4.3._
           */
          function verifyCallResult(
              bool success,
              bytes memory returndata,
              string memory errorMessage
          ) internal pure returns (bytes memory) {
              if (success) {
                  return returndata;
              } else {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @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 v4.7.0) (utils/structs/EnumerableMap.sol)
      pragma solidity ^0.8.0;
      import "./EnumerableSet.sol";
      /**
       * @dev Library for managing an enumerable variant of Solidity's
       * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
       * type.
       *
       * Maps have the following properties:
       *
       * - Entries are added, removed, and checked for existence in constant time
       * (O(1)).
       * - Entries are enumerated in O(n). No guarantees are made on the ordering.
       *
       * ```
       * contract Example {
       *     // Add the library methods
       *     using EnumerableMap for EnumerableMap.UintToAddressMap;
       *
       *     // Declare a set state variable
       *     EnumerableMap.UintToAddressMap private myMap;
       * }
       * ```
       *
       * The following map types are supported:
       *
       * - `uint256 -> address` (`UintToAddressMap`) since v3.0.0
       * - `address -> uint256` (`AddressToUintMap`) since v4.6.0
       * - `bytes32 -> bytes32` (`Bytes32ToBytes32`) since v4.6.0
       * - `uint256 -> uint256` (`UintToUintMap`) since v4.7.0
       * - `bytes32 -> uint256` (`Bytes32ToUintMap`) since v4.7.0
       *
       * [WARNING]
       * ====
       *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
       *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
       *
       *  In order to clean an EnumerableMap, you can either remove all elements one by one or create a fresh instance using an array of EnumerableMap.
       * ====
       */
      library EnumerableMap {
          using EnumerableSet for EnumerableSet.Bytes32Set;
          // To implement this library for multiple types with as little code
          // repetition as possible, we write it in terms of a generic Map type with
          // bytes32 keys and values.
          // The Map implementation uses private functions, and user-facing
          // implementations (such as Uint256ToAddressMap) are just wrappers around
          // the underlying Map.
          // This means that we can only create new EnumerableMaps for types that fit
          // in bytes32.
          struct Bytes32ToBytes32Map {
              // Storage of keys
              EnumerableSet.Bytes32Set _keys;
              mapping(bytes32 => bytes32) _values;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              Bytes32ToBytes32Map storage map,
              bytes32 key,
              bytes32 value
          ) internal returns (bool) {
              map._values[key] = value;
              return map._keys.add(key);
          }
          /**
           * @dev Removes a key-value pair from a map. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
              delete map._values[key];
              return map._keys.remove(key);
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
              return map._keys.contains(key);
          }
          /**
           * @dev Returns the number of key-value pairs in the map. O(1).
           */
          function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
              return map._keys.length();
          }
          /**
           * @dev Returns the key-value pair stored at position `index` in the map. O(1).
           *
           * Note that there are no guarantees on the ordering of entries inside the
           * array, and it may change when more entries are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
              bytes32 key = map._keys.at(index);
              return (key, map._values[key]);
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
              bytes32 value = map._values[key];
              if (value == bytes32(0)) {
                  return (contains(map, key), bytes32(0));
              } else {
                  return (true, value);
              }
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
              bytes32 value = map._values[key];
              require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
              return value;
          }
          /**
           * @dev Same as {_get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {_tryGet}.
           */
          function get(
              Bytes32ToBytes32Map storage map,
              bytes32 key,
              string memory errorMessage
          ) internal view returns (bytes32) {
              bytes32 value = map._values[key];
              require(value != 0 || contains(map, key), errorMessage);
              return value;
          }
          // UintToUintMap
          struct UintToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              UintToUintMap storage map,
              uint256 key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, bytes32(key), bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
              return remove(map._inner, bytes32(key));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
              return contains(map._inner, bytes32(key));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(UintToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (uint256(key), uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(key)));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              UintToUintMap storage map,
              uint256 key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(key), errorMessage));
          }
          // UintToAddressMap
          struct UintToAddressMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              UintToAddressMap storage map,
              uint256 key,
              address value
          ) internal returns (bool) {
              return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
              return remove(map._inner, bytes32(key));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
              return contains(map._inner, bytes32(key));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(UintToAddressMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (uint256(key), address(uint160(uint256(value))));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           *
           * _Available since v3.4._
           */
          function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
              return (success, address(uint160(uint256(value))));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
              return address(uint160(uint256(get(map._inner, bytes32(key)))));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              UintToAddressMap storage map,
              uint256 key,
              string memory errorMessage
          ) internal view returns (address) {
              return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
          }
          // AddressToUintMap
          struct AddressToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              AddressToUintMap storage map,
              address key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(AddressToUintMap storage map, address key) internal returns (bool) {
              return remove(map._inner, bytes32(uint256(uint160(key))));
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
              return contains(map._inner, bytes32(uint256(uint160(key))));
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(AddressToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (address(uint160(uint256(key))), uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              AddressToUintMap storage map,
              address key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
          }
          // Bytes32ToUintMap
          struct Bytes32ToUintMap {
              Bytes32ToBytes32Map _inner;
          }
          /**
           * @dev Adds a key-value pair to a map, or updates the value for an existing
           * key. O(1).
           *
           * Returns true if the key was added to the map, that is if it was not
           * already present.
           */
          function set(
              Bytes32ToUintMap storage map,
              bytes32 key,
              uint256 value
          ) internal returns (bool) {
              return set(map._inner, key, bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the key was removed from the map, that is if it was present.
           */
          function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
              return remove(map._inner, key);
          }
          /**
           * @dev Returns true if the key is in the map. O(1).
           */
          function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
              return contains(map._inner, key);
          }
          /**
           * @dev Returns the number of elements in the map. O(1).
           */
          function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
              return length(map._inner);
          }
          /**
           * @dev Returns the element stored at position `index` in the set. O(1).
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
              (bytes32 key, bytes32 value) = at(map._inner, index);
              return (key, uint256(value));
          }
          /**
           * @dev Tries to returns the value associated with `key`.  O(1).
           * Does not revert if `key` is not in the map.
           */
          function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
              (bool success, bytes32 value) = tryGet(map._inner, key);
              return (success, uint256(value));
          }
          /**
           * @dev Returns the value associated with `key`.  O(1).
           *
           * Requirements:
           *
           * - `key` must be in the map.
           */
          function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
              return uint256(get(map._inner, key));
          }
          /**
           * @dev Same as {get}, with a custom error message when `key` is not in the map.
           *
           * CAUTION: This function is deprecated because it requires allocating memory for the error
           * message unnecessarily. For custom revert reasons use {tryGet}.
           */
          function get(
              Bytes32ToUintMap storage map,
              bytes32 key,
              string memory errorMessage
          ) internal view returns (uint256) {
              return uint256(get(map._inner, key, errorMessage));
          }
      }
      // SPDX-License-Identifier: MIT
      // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
      pragma solidity ^0.8.0;
      /**
       * @dev Library for managing
       * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
       * types.
       *
       * Sets have the following properties:
       *
       * - Elements are added, removed, and checked for existence in constant time
       * (O(1)).
       * - Elements are enumerated in O(n). No guarantees are made on the ordering.
       *
       * ```
       * contract Example {
       *     // Add the library methods
       *     using EnumerableSet for EnumerableSet.AddressSet;
       *
       *     // Declare a set state variable
       *     EnumerableSet.AddressSet private mySet;
       * }
       * ```
       *
       * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
       * and `uint256` (`UintSet`) are supported.
       *
       * [WARNING]
       * ====
       *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
       *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
       *
       *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
       * ====
       */
      library EnumerableSet {
          // To implement this library for multiple types with as little code
          // repetition as possible, we write it in terms of a generic Set type with
          // bytes32 values.
          // The Set implementation uses private functions, and user-facing
          // implementations (such as AddressSet) are just wrappers around the
          // underlying Set.
          // This means that we can only create new EnumerableSets for types that fit
          // in bytes32.
          struct Set {
              // Storage of set values
              bytes32[] _values;
              // Position of the value in the `values` array, plus 1 because index 0
              // means a value is not in the set.
              mapping(bytes32 => uint256) _indexes;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function _add(Set storage set, bytes32 value) private returns (bool) {
              if (!_contains(set, value)) {
                  set._values.push(value);
                  // The value is stored at length-1, but we add 1 to all indexes
                  // and use 0 as a sentinel value
                  set._indexes[value] = set._values.length;
                  return true;
              } else {
                  return false;
              }
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function _remove(Set storage set, bytes32 value) private returns (bool) {
              // We read and store the value's index to prevent multiple reads from the same storage slot
              uint256 valueIndex = set._indexes[value];
              if (valueIndex != 0) {
                  // Equivalent to contains(set, value)
                  // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
                  // the array, and then remove the last element (sometimes called as 'swap and pop').
                  // This modifies the order of the array, as noted in {at}.
                  uint256 toDeleteIndex = valueIndex - 1;
                  uint256 lastIndex = set._values.length - 1;
                  if (lastIndex != toDeleteIndex) {
                      bytes32 lastValue = set._values[lastIndex];
                      // Move the last value to the index where the value to delete is
                      set._values[toDeleteIndex] = lastValue;
                      // Update the index for the moved value
                      set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
                  }
                  // Delete the slot where the moved value was stored
                  set._values.pop();
                  // Delete the index for the deleted slot
                  delete set._indexes[value];
                  return true;
              } else {
                  return false;
              }
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function _contains(Set storage set, bytes32 value) private view returns (bool) {
              return set._indexes[value] != 0;
          }
          /**
           * @dev Returns the number of values on the set. O(1).
           */
          function _length(Set storage set) private view returns (uint256) {
              return set._values.length;
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function _at(Set storage set, uint256 index) private view returns (bytes32) {
              return set._values[index];
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function _values(Set storage set) private view returns (bytes32[] memory) {
              return set._values;
          }
          // Bytes32Set
          struct Bytes32Set {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _add(set._inner, value);
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
              return _remove(set._inner, value);
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
              return _contains(set._inner, value);
          }
          /**
           * @dev Returns the number of values in the set. O(1).
           */
          function length(Bytes32Set storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
              return _at(set._inner, index);
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
              return _values(set._inner);
          }
          // AddressSet
          struct AddressSet {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(AddressSet storage set, address value) internal returns (bool) {
              return _add(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(AddressSet storage set, address value) internal returns (bool) {
              return _remove(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(AddressSet storage set, address value) internal view returns (bool) {
              return _contains(set._inner, bytes32(uint256(uint160(value))));
          }
          /**
           * @dev Returns the number of values in the set. O(1).
           */
          function length(AddressSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(AddressSet storage set, uint256 index) internal view returns (address) {
              return address(uint160(uint256(_at(set._inner, index))));
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(AddressSet storage set) internal view returns (address[] memory) {
              bytes32[] memory store = _values(set._inner);
              address[] memory result;
              /// @solidity memory-safe-assembly
              assembly {
                  result := store
              }
              return result;
          }
          // UintSet
          struct UintSet {
              Set _inner;
          }
          /**
           * @dev Add a value to a set. O(1).
           *
           * Returns true if the value was added to the set, that is if it was not
           * already present.
           */
          function add(UintSet storage set, uint256 value) internal returns (bool) {
              return _add(set._inner, bytes32(value));
          }
          /**
           * @dev Removes a value from a set. O(1).
           *
           * Returns true if the value was removed from the set, that is if it was
           * present.
           */
          function remove(UintSet storage set, uint256 value) internal returns (bool) {
              return _remove(set._inner, bytes32(value));
          }
          /**
           * @dev Returns true if the value is in the set. O(1).
           */
          function contains(UintSet storage set, uint256 value) internal view returns (bool) {
              return _contains(set._inner, bytes32(value));
          }
          /**
           * @dev Returns the number of values on the set. O(1).
           */
          function length(UintSet storage set) internal view returns (uint256) {
              return _length(set._inner);
          }
          /**
           * @dev Returns the value stored at position `index` in the set. O(1).
           *
           * Note that there are no guarantees on the ordering of values inside the
           * array, and it may change when more values are added or removed.
           *
           * Requirements:
           *
           * - `index` must be strictly less than {length}.
           */
          function at(UintSet storage set, uint256 index) internal view returns (uint256) {
              return uint256(_at(set._inner, index));
          }
          /**
           * @dev Return the entire set in an array
           *
           * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
           * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
           * this function has an unbounded cost, and using it as part of a state-changing function may render the function
           * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
           */
          function values(UintSet storage set) internal view returns (uint256[] memory) {
              bytes32[] memory store = _values(set._inner);
              uint256[] memory result;
              /// @solidity memory-safe-assembly
              assembly {
                  result := store
              }
              return result;
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
      contract BoringOwnableUpgradeableData {
          address public owner;
          address public pendingOwner;
      }
      abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
          function __BoringOwnable_init() internal onlyInitializing {
              owner = msg.sender;
          }
          /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
          /// Can only be invoked by the current `owner`.
          /// @param newOwner Address of the new owner.
          /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`.
          /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise.
          function transferOwnership(
              address newOwner,
              bool direct,
              bool renounce
          ) public onlyOwner {
              if (direct) {
                  // Checks
                  require(newOwner != address(0) || renounce, "Ownable: zero address");
                  // Effects
                  emit OwnershipTransferred(owner, newOwner);
                  owner = newOwner;
                  pendingOwner = address(0);
              } else {
                  // Effects
                  pendingOwner = newOwner;
              }
          }
          /// @notice Needs to be called by `pendingOwner` to claim ownership.
          function claimOwnership() public {
              address _pendingOwner = pendingOwner;
              // Checks
              require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
              // Effects
              emit OwnershipTransferred(owner, _pendingOwner);
              owner = _pendingOwner;
              pendingOwner = address(0);
          }
          /// @notice Only allows the `owner` to execute the function.
          modifier onlyOwner() {
              require(msg.sender == owner, "Ownable: caller is not the owner");
              _;
          }
          uint256[48] private __gap;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      /// Adapted from UniswapV3's Oracle
      library Errors {
          // BulkSeller
          error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
          error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
          error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
          error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
          error BulkNotMaintainer();
          error BulkNotAdmin();
          error BulkSellerAlreadyExisted(address token, address SY, address bulk);
          error BulkSellerInvalidToken(address token, address SY);
          error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
          error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
          // APPROX
          error ApproxFail();
          error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
          error ApproxBinarySearchInputInvalid(
              uint256 approxGuessMin,
              uint256 approxGuessMax,
              uint256 minGuessMin,
              uint256 maxGuessMax
          );
          // MARKET + MARKET MATH CORE
          error MarketExpired();
          error MarketZeroAmountsInput();
          error MarketZeroAmountsOutput();
          error MarketZeroLnImpliedRate();
          error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
          error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
          error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
          error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
          error MarketExchangeRateBelowOne(int256 exchangeRate);
          error MarketProportionMustNotEqualOne();
          error MarketRateScalarBelowZero(int256 rateScalar);
          error MarketScalarRootBelowZero(int256 scalarRoot);
          error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
          error OracleUninitialized();
          error OracleTargetTooOld(uint32 target, uint32 oldest);
          error OracleZeroCardinality();
          error MarketFactoryExpiredPt();
          error MarketFactoryInvalidPt();
          error MarketFactoryMarketExists();
          error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
          error MarketFactoryReserveFeePercentTooHigh(
              uint8 reserveFeePercent,
              uint8 maxReserveFeePercent
          );
          error MarketFactoryZeroTreasury();
          error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
          // ROUTER
          error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
          error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
          error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
          error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
          error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
          error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
          error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
          error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
          error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
          error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
          error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
          error RouterTimeRangeZero();
          error RouterCallbackNotPendleMarket(address caller);
          error RouterInvalidAction(bytes4 selector);
          error RouterKyberSwapDataZero();
          // YIELD CONTRACT
          error YCExpired();
          error YCNotExpired();
          error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
          error YCNothingToRedeem();
          error YCPostExpiryDataNotSet();
          error YCNoFloatingSy();
          // YieldFactory
          error YCFactoryInvalidExpiry();
          error YCFactoryYieldContractExisted();
          error YCFactoryZeroExpiryDivisor();
          error YCFactoryZeroTreasury();
          error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
          error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
          // SY
          error SYInvalidTokenIn(address token);
          error SYInvalidTokenOut(address token);
          error SYZeroDeposit();
          error SYZeroRedeem();
          error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
          error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
          // SY-specific
          error SYQiTokenMintFailed(uint256 errCode);
          error SYQiTokenRedeemFailed(uint256 errCode);
          error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
          error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
          error SYCurveInvalidPid();
          error SYCurve3crvPoolNotFound();
          // Liquidity Mining
          error VCInactivePool(address pool);
          error VCPoolAlreadyActive(address pool);
          error VCZeroVePendle(address user);
          error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
          error VCEpochNotFinalized(uint256 wTime);
          error VCPoolAlreadyAddAndRemoved(address pool);
          error VEInvalidNewExpiry(uint256 newExpiry);
          error VEExceededMaxLockTime();
          error VEInsufficientLockTime();
          error VENotAllowedReduceExpiry();
          error VEZeroAmountLocked();
          error VEPositionNotExpired();
          error VEZeroPosition();
          error VEZeroSlope(uint128 bias, uint128 slope);
          error VEReceiveOldSupply(uint256 msgTime);
          error GCNotPendleMarket(address caller);
          error GCNotVotingController(address caller);
          error InvalidWTime(uint256 wTime);
          error ExpiryInThePast(uint256 expiry);
          error ChainNotSupported(uint256 chainId);
          error FDCantFundFutureEpoch();
          error FDFactoryDistributorAlreadyExisted(address pool, address distributor);
          // Cross-Chain
          error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
          error MsgNotFromReceiveEndpoint(address sender);
          error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
          error ApproxDstExecutionGasNotSet();
          error InvalidRetryData();
          // GENERIC MSG
          error ArrayLengthMismatch();
          error ArrayEmpty();
          error ArrayOutOfBounds();
          error ZeroAddress();
          error OnlyLayerZeroEndpoint();
          error OnlyYT();
          error OnlyYCFactory();
          error OnlyWhitelisted();
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      // This program is free software: you can redistribute it and/or modify
      // it under the terms of the GNU General Public License as published by
      // the Free Software Foundation, either version 3 of the License, or
      // (at your option) any later version.
      // This program is distributed in the hope that it will be useful,
      // but WITHOUT ANY WARRANTY; without even the implied warranty of
      // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      // GNU General Public License for more details.
      // You should have received a copy of the GNU General Public License
      // along with this program.  If not, see <http://www.gnu.org/licenses/>.
      pragma solidity 0.8.17;
      /* solhint-disable private-vars-leading-underscore, reason-string */
      library Math {
          uint256 internal constant ONE = 1e18; // 18 decimal places
          int256 internal constant IONE = 1e18; // 18 decimal places
          function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
              unchecked {
                  return (a >= b ? a - b : 0);
              }
          }
          function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
              require(a >= b, "negative");
              return a - b; // no unchecked since if b is very negative, a - b might overflow
          }
          function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 product = a * b;
              unchecked {
                  return product / ONE;
              }
          }
          function mulDown(int256 a, int256 b) internal pure returns (int256) {
              int256 product = a * b;
              unchecked {
                  return product / IONE;
              }
          }
          function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
              uint256 aInflated = a * ONE;
              unchecked {
                  return aInflated / b;
              }
          }
          function divDown(int256 a, int256 b) internal pure returns (int256) {
              int256 aInflated = a * IONE;
              unchecked {
                  return aInflated / b;
              }
          }
          function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
              return (a + b - 1) / b;
          }
          // @author Uniswap
          function sqrt(uint256 y) internal pure returns (uint256 z) {
              if (y > 3) {
                  z = y;
                  uint256 x = y / 2 + 1;
                  while (x < z) {
                      z = x;
                      x = (y / x + x) / 2;
                  }
              } else if (y != 0) {
                  z = 1;
              }
          }
          function abs(int256 x) internal pure returns (uint256) {
              return uint256(x > 0 ? x : -x);
          }
          function neg(int256 x) internal pure returns (int256) {
              return x * (-1);
          }
          function neg(uint256 x) internal pure returns (int256) {
              return Int(x) * (-1);
          }
          function max(uint256 x, uint256 y) internal pure returns (uint256) {
              return (x > y ? x : y);
          }
          function max(int256 x, int256 y) internal pure returns (int256) {
              return (x > y ? x : y);
          }
          function min(uint256 x, uint256 y) internal pure returns (uint256) {
              return (x < y ? x : y);
          }
          function min(int256 x, int256 y) internal pure returns (int256) {
              return (x < y ? x : y);
          }
          /*///////////////////////////////////////////////////////////////
                                     SIGNED CASTS
          //////////////////////////////////////////////////////////////*/
          function Int(uint256 x) internal pure returns (int256) {
              require(x <= uint256(type(int256).max));
              return int256(x);
          }
          function Int128(int256 x) internal pure returns (int128) {
              require(type(int128).min <= x && x <= type(int128).max);
              return int128(x);
          }
          function Int128(uint256 x) internal pure returns (int128) {
              return Int128(Int(x));
          }
          /*///////////////////////////////////////////////////////////////
                                     UNSIGNED CASTS
          //////////////////////////////////////////////////////////////*/
          function Uint(int256 x) internal pure returns (uint256) {
              require(x >= 0);
              return uint256(x);
          }
          function Uint32(uint256 x) internal pure returns (uint32) {
              require(x <= type(uint32).max);
              return uint32(x);
          }
          function Uint112(uint256 x) internal pure returns (uint112) {
              require(x <= type(uint112).max);
              return uint112(x);
          }
          function Uint96(uint256 x) internal pure returns (uint96) {
              require(x <= type(uint96).max);
              return uint96(x);
          }
          function Uint128(uint256 x) internal pure returns (uint128) {
              require(x <= type(uint128).max);
              return uint128(x);
          }
          function isAApproxB(
              uint256 a,
              uint256 b,
              uint256 eps
          ) internal pure returns (bool) {
              return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
          }
          function isAGreaterApproxB(
              uint256 a,
              uint256 b,
              uint256 eps
          ) internal pure returns (bool) {
              return a >= b && a <= mulDown(b, ONE + eps);
          }
          function isASmallerApproxB(
              uint256 a,
              uint256 b,
              uint256 eps
          ) internal pure returns (bool) {
              return a <= b && a >= mulDown(b, ONE - eps);
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      library MiniHelpers {
          function isCurrentlyExpired(uint256 expiry) internal view returns (bool) {
              return (expiry <= block.timestamp);
          }
          function isExpired(uint256 expiry, uint256 blockTime) internal pure returns (bool) {
              return (expiry <= blockTime);
          }
          function isTimeInThePast(uint256 timestamp) internal view returns (bool) {
              return (timestamp <= block.timestamp); // same definition as isCurrentlyExpired
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity >=0.8.0;
      interface IPMsgSendEndpoint {
          function calcFee(
              address dstAddress,
              uint256 dstChainId,
              bytes memory payload,
              uint256 estimatedGasAmount
          ) external view returns (uint256 fee);
          function sendMessage(
              address dstAddress,
              uint256 dstChainId,
              bytes calldata payload,
              uint256 estimatedGasAmount
          ) external payable;
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      interface IPVeToken {
          // ============= USER INFO =============
          function balanceOf(address user) external view returns (uint128);
          function positionData(address user) external view returns (uint128 amount, uint128 expiry);
          // ============= META DATA =============
          function totalSupplyStored() external view returns (uint128);
          function totalSupplyCurrent() external returns (uint128);
          function totalSupplyAndBalanceCurrent(address user) external returns (uint128, uint128);
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "./IPVeToken.sol";
      import "../LiquidityMining/libraries/VeBalanceLib.sol";
      import "../LiquidityMining/libraries/VeHistoryLib.sol";
      interface IPVotingEscrowMainchain is IPVeToken {
          event NewLockPosition(address indexed user, uint128 amount, uint128 expiry);
          event Withdraw(address indexed user, uint128 amount);
          event BroadcastTotalSupply(VeBalance newTotalSupply, uint256[] chainIds);
          event BroadcastUserPosition(address indexed user, uint256[] chainIds);
          // ============= ACTIONS =============
          function increaseLockPosition(uint128 additionalAmountToLock, uint128 expiry)
              external
              returns (uint128);
          function withdraw() external returns (uint128);
          function totalSupplyAt(uint128 timestamp) external view returns (uint128);
          function getUserHistoryLength(address user) external view returns (uint256);
          function getUserHistoryAt(address user, uint256 index)
              external
              view
              returns (Checkpoint memory);
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../interfaces/IPMsgSendEndpoint.sol";
      import "../../core/libraries/BoringOwnableUpgradeable.sol";
      import "../../core/libraries/Errors.sol";
      import "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
      // solhint-disable no-empty-blocks
      abstract contract PendleMsgSenderAppUpg is BoringOwnableUpgradeable {
          using EnumerableMap for EnumerableMap.UintToAddressMap;
          uint256 public approxDstExecutionGas;
          IPMsgSendEndpoint public immutable pendleMsgSendEndpoint;
          // destinationContracts mapping contains one address for each chainId only
          EnumerableMap.UintToAddressMap internal destinationContracts;
          uint256[100] private __gap;
          modifier refundUnusedEth() {
              _;
              if (address(this).balance > 0) {
                  AddressUpgradeable.sendValue(payable(msg.sender), address(this).balance);
              }
          }
          constructor(address _pendleMsgSendEndpoint, uint256 _approxDstExecutionGas) {
              pendleMsgSendEndpoint = IPMsgSendEndpoint(_pendleMsgSendEndpoint);
              approxDstExecutionGas = _approxDstExecutionGas;
          }
          function _sendMessage(uint256 chainId, bytes memory message) internal {
              assert(destinationContracts.contains(chainId));
              address toAddr = destinationContracts.get(chainId);
              uint256 estimatedGasAmount = approxDstExecutionGas;
              uint256 fee = pendleMsgSendEndpoint.calcFee(toAddr, chainId, message, estimatedGasAmount);
              // LM contracts won't hold ETH on its own so this is fine
              if (address(this).balance < fee)
                  revert Errors.InsufficientFeeToSendMsg(address(this).balance, fee);
              pendleMsgSendEndpoint.sendMessage{ value: fee }(
                  toAddr,
                  chainId,
                  message,
                  estimatedGasAmount
              );
          }
          function addDestinationContract(address _address, uint256 _chainId)
              external
              payable
              onlyOwner
          {
              destinationContracts.set(_chainId, _address);
          }
          function setApproxDstExecutionGas(uint256 gas) external onlyOwner {
              approxDstExecutionGas = gas;
          }
          function getAllDestinationContracts()
              public
              view
              returns (uint256[] memory chainIds, address[] memory addrs)
          {
              uint256 length = destinationContracts.length();
              chainIds = new uint256[](length);
              addrs = new address[](length);
              for (uint256 i = 0; i < length; ++i) {
                  (chainIds[i], addrs[i]) = destinationContracts.at(i);
              }
          }
          function _getSendMessageFee(uint256 chainId, bytes memory message)
              internal
              view
              returns (uint256)
          {
              return
                  pendleMsgSendEndpoint.calcFee(
                      destinationContracts.get(chainId),
                      chainId,
                      message,
                      approxDstExecutionGas
                  );
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../core/libraries/math/Math.sol";
      import "../../core/libraries/Errors.sol";
      struct VeBalance {
          uint128 bias;
          uint128 slope;
      }
      struct LockedPosition {
          uint128 amount;
          uint128 expiry;
      }
      library VeBalanceLib {
          using Math for uint256;
          uint128 internal constant MAX_LOCK_TIME = 104 weeks;
          uint256 internal constant USER_VOTE_MAX_WEIGHT = 10**18;
          function add(VeBalance memory a, VeBalance memory b)
              internal
              pure
              returns (VeBalance memory res)
          {
              res.bias = a.bias + b.bias;
              res.slope = a.slope + b.slope;
          }
          function sub(VeBalance memory a, VeBalance memory b)
              internal
              pure
              returns (VeBalance memory res)
          {
              res.bias = a.bias - b.bias;
              res.slope = a.slope - b.slope;
          }
          function sub(
              VeBalance memory a,
              uint128 slope,
              uint128 expiry
          ) internal pure returns (VeBalance memory res) {
              res.slope = a.slope - slope;
              res.bias = a.bias - slope * expiry;
          }
          function isExpired(VeBalance memory a) internal view returns (bool) {
              return a.slope * uint128(block.timestamp) >= a.bias;
          }
          function getCurrentValue(VeBalance memory a) internal view returns (uint128) {
              if (isExpired(a)) return 0;
              return getValueAt(a, uint128(block.timestamp));
          }
          function getValueAt(VeBalance memory a, uint128 t) internal pure returns (uint128) {
              if (a.slope * t > a.bias) {
                  return 0;
              }
              return a.bias - a.slope * t;
          }
          function getExpiry(VeBalance memory a) internal pure returns (uint128) {
              if (a.slope == 0) revert Errors.VEZeroSlope(a.bias, a.slope);
              return a.bias / a.slope;
          }
          function convertToVeBalance(LockedPosition memory position)
              internal
              pure
              returns (VeBalance memory res)
          {
              res.slope = position.amount / MAX_LOCK_TIME;
              res.bias = res.slope * position.expiry;
          }
          function convertToVeBalance(LockedPosition memory position, uint256 weight)
              internal
              pure
              returns (VeBalance memory res)
          {
              res.slope = ((position.amount * weight) / MAX_LOCK_TIME / USER_VOTE_MAX_WEIGHT).Uint128();
              res.bias = res.slope * position.expiry;
          }
          function convertToVeBalance(uint128 amount, uint128 expiry)
              internal
              pure
              returns (uint128, uint128)
          {
              VeBalance memory balance = convertToVeBalance(LockedPosition(amount, expiry));
              return (balance.bias, balance.slope);
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      // Forked from OpenZeppelin (v4.5.0) (utils/Checkpoints.sol)
      pragma solidity ^0.8.0;
      import "../../core/libraries/math/Math.sol";
      import "./VeBalanceLib.sol";
      import "./WeekMath.sol";
      struct Checkpoint {
          uint128 timestamp;
          VeBalance value;
      }
      library CheckpointHelper {
          function assignWith(Checkpoint memory a, Checkpoint memory b) internal pure {
              a.timestamp = b.timestamp;
              a.value = b.value;
          }
      }
      library Checkpoints {
          struct History {
              Checkpoint[] _checkpoints;
          }
          function length(History storage self) internal view returns (uint256) {
              return self._checkpoints.length;
          }
          function get(History storage self, uint256 index) internal view returns (Checkpoint memory) {
              return self._checkpoints[index];
          }
          function push(History storage self, VeBalance memory value) internal {
              uint256 pos = self._checkpoints.length;
              if (pos > 0 && self._checkpoints[pos - 1].timestamp == WeekMath.getCurrentWeekStart()) {
                  self._checkpoints[pos - 1].value = value;
              } else {
                  self._checkpoints.push(
                      Checkpoint({ timestamp: WeekMath.getCurrentWeekStart(), value: value })
                  );
              }
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      library WeekMath {
          uint128 internal constant WEEK = 7 days;
          function getWeekStartTimestamp(uint128 timestamp) internal pure returns (uint128) {
              return (timestamp / WEEK) * WEEK;
          }
          function getCurrentWeekStart() internal view returns (uint128) {
              return getWeekStartTimestamp(uint128(block.timestamp));
          }
          function isValidWTime(uint256 time) internal pure returns (bool) {
              return time % WEEK == 0;
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
      import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
      import "../../interfaces/IPVotingEscrowMainchain.sol";
      import "../libraries/VeHistoryLib.sol";
      import "../../core/libraries/MiniHelpers.sol";
      import "../../core/libraries/Errors.sol";
      import "./VotingEscrowTokenBase.sol";
      import "../CrossChainMsg/PendleMsgSenderAppUpg.sol";
      contract VotingEscrowPendleMainchain is
          VotingEscrowTokenBase,
          IPVotingEscrowMainchain,
          PendleMsgSenderAppUpg
      {
          using SafeERC20 for IERC20;
          using VeBalanceLib for VeBalance;
          using VeBalanceLib for LockedPosition;
          using Checkpoints for Checkpoints.History;
          using EnumerableMap for EnumerableMap.UintToAddressMap;
          bytes private constant EMPTY_BYTES = abi.encode();
          bytes private constant SAMPLE_SUPPLY_UPDATE_MESSAGE =
              abi.encode(0, VeBalance(0, 0), EMPTY_BYTES);
          bytes private constant SAMPLE_POSITION_UPDATE_MESSAGE =
              abi.encode(0, VeBalance(0, 0), abi.encode(address(0), LockedPosition(0, 0)));
          IERC20 public immutable pendle;
          uint128 public lastSlopeChangeAppliedAt;
          // [wTime] => slopeChanges
          mapping(uint128 => uint128) public slopeChanges;
          // Saving totalSupply checkpoint for each week, later can be used for reward accounting
          // [wTime] => totalSupply
          mapping(uint128 => uint128) public totalSupplyAt;
          // Saving VeBalance checkpoint for users of each week, can later use binary search
          // to ask for their vePendle balance at any wTime
          mapping(address => Checkpoints.History) internal userHistory;
          constructor(
              IERC20 _pendle,
              address _pendleMsgSendEndpoint,
              uint256 initialApproxDestinationGas
          ) initializer PendleMsgSenderAppUpg(_pendleMsgSendEndpoint, initialApproxDestinationGas) {
              pendle = _pendle;
              lastSlopeChangeAppliedAt = WeekMath.getCurrentWeekStart();
              __BoringOwnable_init();
          }
          /// @notice basically a proxy function to call increaseLockPosition & broadcastUserPosition at the same time
          function increaseLockPositionAndBroadcast(
              uint128 additionalAmountToLock,
              uint128 newExpiry,
              uint256[] calldata chainIds
          ) external payable refundUnusedEth returns (uint128 newVeBalance) {
              newVeBalance = increaseLockPosition(additionalAmountToLock, newExpiry);
              broadcastUserPosition(msg.sender, chainIds);
          }
          /**
           * @notice increases the lock position of a user (amount and/or expiry). Applicable even when
           * user has no position or the current position has expired.
           * @param additionalAmountToLock pendle amount to be pulled in from user to lock.
           * @param newExpiry new lock expiry. Must be a valid week beginning, and resulting lock
           * duration (since `block.timestamp`) must be within the allowed range.
           * @dev Will revert if resulting position has zero lock amount.
           * @dev See `_increasePosition()` for details on inner workings.
           * @dev Sidechain broadcasting is not bundled since it can be done anytime after.
           */
          function increaseLockPosition(uint128 additionalAmountToLock, uint128 newExpiry)
              public
              returns (uint128 newVeBalance)
          {
              address user = msg.sender;
              if (!WeekMath.isValidWTime(newExpiry)) revert Errors.InvalidWTime(newExpiry);
              if (MiniHelpers.isTimeInThePast(newExpiry)) revert Errors.ExpiryInThePast(newExpiry);
              if (newExpiry < positionData[user].expiry) revert Errors.VENotAllowedReduceExpiry();
              if (newExpiry > block.timestamp + MAX_LOCK_TIME) revert Errors.VEExceededMaxLockTime();
              if (newExpiry < block.timestamp + MIN_LOCK_TIME) revert Errors.VEInsufficientLockTime();
              uint128 newTotalAmountLocked = additionalAmountToLock + positionData[user].amount;
              if (newTotalAmountLocked == 0) revert Errors.VEZeroAmountLocked();
              uint128 additionalDurationToLock = newExpiry - positionData[user].expiry;
              if (additionalAmountToLock > 0) {
                  pendle.safeTransferFrom(user, address(this), additionalAmountToLock);
              }
              newVeBalance = _increasePosition(user, additionalAmountToLock, additionalDurationToLock);
              emit NewLockPosition(user, newTotalAmountLocked, newExpiry);
          }
          /**
           * @notice Withdraws an expired lock position, returns locked PENDLE back to user
           * @dev reverts if position is not expired, or if no locked PENDLE to withdraw
           * @dev broadcast is not bundled since it can be done anytime after
           */
          function withdraw() external returns (uint128 amount) {
              address user = msg.sender;
              if (!_isPositionExpired(user)) revert Errors.VEPositionNotExpired();
              amount = positionData[user].amount;
              if (amount == 0) revert Errors.VEZeroPosition();
              delete positionData[user];
              pendle.safeTransfer(user, amount);
              emit Withdraw(user, amount);
          }
          /**
           * @notice update & return the current totalSupply, but does not broadcast info to other chains
           * @dev See `broadcastTotalSupply()` and `broadcastUserPosition()` for broadcasting
           */
          function totalSupplyCurrent()
              public
              virtual
              override(IPVeToken, VotingEscrowTokenBase)
              returns (uint128)
          {
              (VeBalance memory supply, ) = _applySlopeChange();
              return supply.getCurrentValue();
          }
          /// @notice updates and broadcast the current totalSupply to different chains
          function broadcastTotalSupply(uint256[] calldata chainIds) public payable refundUnusedEth {
              _broadcastPosition(address(0), chainIds);
          }
          /**
           * @notice updates and broadcast the position of `user` to different chains, also updates and
           * broadcasts totalSupply
           */
          function broadcastUserPosition(address user, uint256[] calldata chainIds)
              public
              payable
              refundUnusedEth
          {
              if (user == address(0)) revert Errors.ZeroAddress();
              _broadcastPosition(user, chainIds);
          }
          function getUserHistoryLength(address user) external view returns (uint256) {
              return userHistory[user].length();
          }
          function getUserHistoryAt(address user, uint256 index)
              external
              view
              returns (Checkpoint memory)
          {
              return userHistory[user].get(index);
          }
          function getBroadcastSupplyFee(uint256[] calldata chainIds)
              external
              view
              returns (uint256 fee)
          {
              for (uint256 i = 0; i < chainIds.length; i++) {
                  fee += _getSendMessageFee(chainIds[i], SAMPLE_SUPPLY_UPDATE_MESSAGE);
              }
          }
          function getBroadcastPositionFee(uint256[] calldata chainIds)
              external
              view
              returns (uint256 fee)
          {
              for (uint256 i = 0; i < chainIds.length; i++) {
                  fee += _getSendMessageFee(chainIds[i], SAMPLE_POSITION_UPDATE_MESSAGE);
              }
          }
          /**
           * @notice increase the locking position of the user
           * @dev works by simply removing the old position from all relevant data (as if the user has
           * never locked) and then add in the new position
           */
          function _increasePosition(
              address user,
              uint128 amountToIncrease,
              uint128 durationToIncrease
          ) internal returns (uint128) {
              LockedPosition memory oldPosition = positionData[user];
              (VeBalance memory newSupply, ) = _applySlopeChange();
              if (!MiniHelpers.isCurrentlyExpired(oldPosition.expiry)) {
                  // remove old position not yet expired
                  VeBalance memory oldBalance = oldPosition.convertToVeBalance();
                  newSupply = newSupply.sub(oldBalance);
                  slopeChanges[oldPosition.expiry] -= oldBalance.slope;
              }
              LockedPosition memory newPosition = LockedPosition(
                  oldPosition.amount + amountToIncrease,
                  oldPosition.expiry + durationToIncrease
              );
              VeBalance memory newBalance = newPosition.convertToVeBalance();
              // add new position
              newSupply = newSupply.add(newBalance);
              slopeChanges[newPosition.expiry] += newBalance.slope;
              _totalSupply = newSupply;
              positionData[user] = newPosition;
              userHistory[user].push(newBalance);
              return newBalance.getCurrentValue();
          }
          /**
           * @notice updates the totalSupply, processing all slope changes of past weeks. At the same time,
           * set the finalized totalSupplyAt
           */
          function _applySlopeChange() internal returns (VeBalance memory, uint128) {
              VeBalance memory supply = _totalSupply;
              uint128 wTime = lastSlopeChangeAppliedAt;
              uint128 currentWeekStart = WeekMath.getCurrentWeekStart();
              if (wTime >= currentWeekStart) {
                  return (supply, wTime);
              }
              while (wTime < currentWeekStart) {
                  wTime += WEEK;
                  supply = supply.sub(slopeChanges[wTime], wTime);
                  totalSupplyAt[wTime] = supply.getValueAt(wTime);
              }
              _totalSupply = supply;
              lastSlopeChangeAppliedAt = wTime;
              return (supply, wTime);
          }
          /// @notice broadcast position to all chains in chainIds
          function _broadcastPosition(address user, uint256[] calldata chainIds) internal {
              if (chainIds.length == 0) revert Errors.ArrayEmpty();
              (VeBalance memory supply, ) = _applySlopeChange();
              bytes memory userData = (
                  user == address(0) ? EMPTY_BYTES : abi.encode(user, positionData[user])
              );
              for (uint256 i = 0; i < chainIds.length; ++i) {
                  if (!destinationContracts.contains(chainIds[i]))
                      revert Errors.ChainNotSupported(chainIds[i]);
                  _broadcast(chainIds[i], uint128(block.timestamp), supply, userData);
              }
              if (user != address(0)) {
                  emit BroadcastUserPosition(user, chainIds);
              }
              emit BroadcastTotalSupply(supply, chainIds);
          }
          function _broadcast(
              uint256 chainId,
              uint128 msgTime,
              VeBalance memory supply,
              bytes memory userData
          ) internal {
              _sendMessage(chainId, abi.encode(msgTime, supply, userData));
          }
      }
      // SPDX-License-Identifier: GPL-3.0-or-later
      pragma solidity 0.8.17;
      import "../../interfaces/IPVeToken.sol";
      import "../../core/libraries/MiniHelpers.sol";
      import "../libraries/VeBalanceLib.sol";
      import "../libraries/WeekMath.sol";
      /**
       * @dev this contract is an abstract for its mainchain and sidechain variant
       * PRINCIPLE:
       *   - All functions implemented in this contract should be either view or pure
       *     to ensure that no writing logic is inherited by sidechain version
       *   - Mainchain version will handle the logic which are:
       *        + Deposit, withdraw, increase lock, increase amount
       *        + Mainchain logic will be ensured to have _totalSupply = linear sum of
       *          all users' veBalance such that their locks are not yet expired
       *        + Mainchain contract reserves 100% the right to write on sidechain
       *        + No other transaction is allowed to write on sidechain storage
       */
      abstract contract VotingEscrowTokenBase is IPVeToken {
          using VeBalanceLib for VeBalance;
          using VeBalanceLib for LockedPosition;
          uint128 public constant WEEK = 1 weeks;
          uint128 public constant MAX_LOCK_TIME = 104 weeks;
          uint128 public constant MIN_LOCK_TIME = 1 weeks;
          VeBalance internal _totalSupply;
          mapping(address => LockedPosition) public positionData;
          constructor() {}
          function balanceOf(address user) public view virtual returns (uint128) {
              return positionData[user].convertToVeBalance().getCurrentValue();
          }
          function totalSupplyStored() public view virtual returns (uint128) {
              return _totalSupply.getCurrentValue();
          }
          function totalSupplyCurrent() public virtual returns (uint128);
          function _isPositionExpired(address user) internal view returns (bool) {
              return MiniHelpers.isCurrentlyExpired(positionData[user].expiry);
          }
          function totalSupplyAndBalanceCurrent(address user) external returns (uint128, uint128) {
              return (totalSupplyCurrent(), balanceOf(user));
          }
      }